* VĂ©rifier si tout est correct dans la traduction.
* Si nĂ©cessaire, amĂ©liorer votre invite spĂ©cifique Ă la langue, lâinvite gĂ©nĂ©rale, ou le document anglais.
* Corriger ensuite manuellement les problĂšmes restants dans la traduction, afin que ce soit une bonne traduction.
-* Retraduire, en ayant la bonne traduction en place. Le rĂ©sultat idĂ©al serait que le LLM ne fasse plus aucun changement Ă la traduction. Cela signifie que lâinvite gĂ©nĂ©rale et votre invite spĂ©cifique Ă la langue sont aussi bonnes que possible (il fera parfois quelques changements apparemment alĂ©atoires, la raison Ă©tant que <a href="https://doublespeak.chat/#/handbook#deterministic-output" class="external-link" target="_blank">les LLM ne sont pas des algorithmes dĂ©terministes</a>).
+* Retraduire, en ayant la bonne traduction en place. Le rĂ©sultat idĂ©al serait que le LLM ne fasse plus aucun changement Ă la traduction. Cela signifie que lâinvite gĂ©nĂ©rale et votre invite spĂ©cifique Ă la langue sont aussi bonnes que possible (il fera parfois quelques changements apparemment alĂ©atoires, la raison Ă©tant que [les LLM ne sont pas des algorithmes dĂ©terministes](https://doublespeak.chat/#/handbook#deterministic-output)).
Les tests :
Le texte du lien doit ĂȘtre traduit, lâadresse du lien doit rester inchangĂ©e :
* [Lien vers le titre ci-dessus](#code-snippets)
-* [Lien interne](index.md#installation){.internal-link target=_blank}
-* <a href="https://sqlmodel.tiangolo.com/" class="external-link" target="_blank">Lien externe</a>
-* <a href="https://fastapi.tiangolo.com/css/styles.css" class="external-link" target="_blank">Lien vers une feuille de style</a>
-* <a href="https://fastapi.tiangolo.com/js/logic.js" class="external-link" target="_blank">Lien vers un script</a>
-* <a href="https://fastapi.tiangolo.com/img/foo.jpg" class="external-link" target="_blank">Lien vers une image</a>
+* [Lien interne](index.md#installation)
+* [Lien externe](https://sqlmodel.tiangolo.com/)
+* [Lien vers une feuille de style](https://fastapi.tiangolo.com/css/styles.css)
+* [Lien vers un script](https://fastapi.tiangolo.com/js/logic.js)
+* [Lien vers une image](https://fastapi.tiangolo.com/img/foo.jpg)
Le texte du lien doit ĂȘtre traduit, lâadresse du lien doit pointer vers la traduction :
-* <a href="https://fastapi.tiangolo.com/fr/" class="external-link" target="_blank">Lien FastAPI</a>
+* [Lien FastAPI](https://fastapi.tiangolo.com/fr/)
////
Bonjour.
-### Annotations de type et indications de type { #type-hints-and-annotations }
+### Annotations de type et annotations de type { #type-hints-and-annotations }
Rebonjour.
Pour voir exactement ce que vous pouvez inclure dans les réponses, vous pouvez consulter ces sections dans la spécification OpenAPI :
-* <a href="https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md#responses-object" class="external-link" target="_blank">Objet Responses de OpenAPI</a>, il inclut le `Response Object`.
-* <a href="https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md#response-object" class="external-link" target="_blank">Objet Response de OpenAPI</a>, vous pouvez inclure n'importe quoi directement dans chaque réponse à l'intérieur de votre paramÚtre `responses`. Y compris `description`, `headers`, `content` (à l'intérieur de cela, vous déclarez différents types de médias et schémas JSON) et `links`.
+* [Objet Responses de OpenAPI](https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md#responses-object), il inclut le `Response Object`.
+* [Objet Response de OpenAPI](https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md#response-object), vous pouvez inclure n'importe quoi directement dans chaque réponse à l'intérieur de votre paramÚtre `responses`. Y compris `description`, `headers`, `content` (à l'intérieur de cela, vous déclarez différents types de médias et schémas JSON) et `links`.
Lorsque vous renvoyez une `Response` directement, comme dans l'exemple ci-dessus, elle sera renvoyée directement.
-Elle ne sera pas sérialisée avec un modÚle.
+Elle ne sera pas sérialisée avec un modÚle, etc.
-Assurez-vous qu'il contient les données souhaitées et que les valeurs sont dans un format JSON valide (si vous utilisez une `JSONResponse`).
+Vous devez vous assurer qu'elle contient les données souhaitées et que les valeurs sont dans un format JSON valide (si vous utilisez une `JSONResponse`).
///
Vous pouvez Ă©galement utiliser `from starlette.responses import JSONResponse`.
-Pour plus de commoditĂ©s, **FastAPI** fournit les objets `starlette.responses` sous forme d'un alias accessible par `fastapi.responses`. Mais la plupart des rĂ©ponses disponibles proviennent directement de Starlette. Il en est de mĂȘme avec `status`.
+Par commoditĂ© pour vous, le dĂ©veloppeur, **FastAPI** fournit les mĂȘmes `starlette.responses` sous la forme de `fastapi.responses`. Mais la plupart des rĂ©ponses disponibles proviennent directement de Starlette. Il en est de mĂȘme avec `status`.
///
Si vous renvoyez directement des codes HTTP et des réponses supplémentaires, ils ne seront pas inclus dans le schéma OpenAPI (les documents de l'API), car FastAPI n'a aucun moyen de savoir à l'avance ce que vous allez renvoyer.
-Mais vous pouvez documenter cela dans votre code, en utilisant : [Réponses supplémentaires](additional-responses.md){.internal-link target=_blank}.
+Mais vous pouvez documenter cela dans votre code, en utilisant : [Réponses supplémentaires](additional-responses.md).
De cette maniĂšre, la session libĂ©rera la connexion Ă la base de donnĂ©es, afin que dâautres requĂȘtes puissent lâutiliser.
-Si vous avez un autre cas dâutilisation qui nĂ©cessite une sortie anticipĂ©e depuis une dĂ©pendance avec `yield`, veuillez crĂ©er une <a href="https://github.com/fastapi/fastapi/discussions/new?category=questions" class="external-link" target="_blank">Question de discussion GitHub</a> avec votre cas spĂ©cifique et pourquoi vous bĂ©nĂ©ficieriez dâune fermeture anticipĂ©e pour les dĂ©pendances avec `yield`.
+Si vous avez un autre cas dâutilisation qui nĂ©cessite une sortie anticipĂ©e depuis une dĂ©pendance avec `yield`, veuillez crĂ©er une [Question de discussion GitHub](https://github.com/fastapi/fastapi/discussions/new?category=questions) avec votre cas spĂ©cifique et pourquoi vous bĂ©nĂ©ficieriez dâune fermeture anticipĂ©e pour les dĂ©pendances avec `yield`.
Sâil existe des cas dâutilisation convaincants pour une fermeture anticipĂ©e dans les dĂ©pendances avec `yield`, jâenvisagerai dâajouter une nouvelle façon dây opter.
### TĂąches d'arriĂšreâplan et dĂ©pendances avec `yield`, DĂ©tails techniques { #background-tasks-and-dependencies-with-yield-technical-details }
-Avant FastAPI 0.106.0, lever des exceptions aprĂšs `yield` nâĂ©tait pas possible, le code dâarrĂȘt dans les dĂ©pendances avec `yield` sâexĂ©cutait aprĂšs lâenvoi de la rĂ©ponse, donc les [Gestionnaires d'exceptions](../tutorial/handling-errors.md#install-custom-exception-handlers){.internal-link target=_blank} avaient dĂ©jĂ Ă©tĂ© exĂ©cutĂ©s.
+Avant FastAPI 0.106.0, lever des exceptions aprĂšs `yield` nâĂ©tait pas possible, le code dâarrĂȘt dans les dĂ©pendances avec `yield` sâexĂ©cutait aprĂšs lâenvoi de la rĂ©ponse, donc les [Gestionnaires d'exceptions](../tutorial/handling-errors.md#install-custom-exception-handlers) avaient dĂ©jĂ Ă©tĂ© exĂ©cutĂ©s.
Cela avait Ă©tĂ© conçu ainsi principalement pour permettre dâutiliser les mĂȘmes objets « gĂ©nĂ©rĂ©s par yield » par les dĂ©pendances Ă lâintĂ©rieur de tĂąches dâarriĂšreâplan, car le code dâarrĂȘt sâexĂ©cutait aprĂšs la fin des tĂąches dâarriĂšreâplan.
Le `TestClient` fait un peu de magie pour appeler l'application FastAPI asynchrone depuis vos fonctions de test `def` normales, en utilisant pytest standard. Mais cette magie ne fonctionne plus lorsque nous l'utilisons dans des fonctions asynchrones. En exécutant nos tests de maniÚre asynchrone, nous ne pouvons plus utiliser le `TestClient` dans nos fonctions de test.
-Le `TestClient` est basé sur <a href="https://www.python-httpx.org" class="external-link" target="_blank">HTTPX</a> et, heureusement, nous pouvons l'utiliser directement pour tester l'API.
+Le `TestClient` est basé sur [HTTPX](https://www.python-httpx.org) et, heureusement, nous pouvons l'utiliser directement pour tester l'API.
## Exemple { #example }
-Pour un exemple simple, considérons une structure de fichiers similaire à celle décrite dans [Applications plus grandes](../tutorial/bigger-applications.md){.internal-link target=_blank} et [Tests](../tutorial/testing.md){.internal-link target=_blank} :
+Pour un exemple simple, considérons une structure de fichiers similaire à celle décrite dans [Applications plus grandes](../tutorial/bigger-applications.md) et [Tests](../tutorial/testing.md) :
```
.
/// warning | Alertes
-Si votre application s'appuie sur des événements de cycle de vie (lifespan), le `AsyncClient` ne déclenchera pas ces événements. Pour vous assurer qu'ils sont déclenchés, utilisez `LifespanManager` depuis <a href="https://github.com/florimondmanca/asgi-lifespan#usage" class="external-link" target="_blank">florimondmanca/asgi-lifespan</a>.
+Si votre application s'appuie sur des événements de cycle de vie, l'`AsyncClient` ne déclenchera pas ces événements. Pour vous assurer qu'ils sont déclenchés, utilisez `LifespanManager` depuis [florimondmanca/asgi-lifespan](https://github.com/florimondmanca/asgi-lifespan#usage).
///
/// tip | Astuce
-Si vous rencontrez une erreur `RuntimeError: Task attached to a different loop` lors de l'intégration d'appels de fonctions asynchrones dans vos tests (par exemple en utilisant <a href="https://stackoverflow.com/questions/41584243/runtimeerror-task-attached-to-a-different-loop" class="external-link" target="_blank">MotorClient de MongoDB</a>), n'oubliez pas d'instancier les objets qui ont besoin d'une boucle d'événements uniquement dans des fonctions async, par exemple dans un callback `@app.on_event("startup")`.
+Si vous rencontrez une erreur `RuntimeError: Task attached to a different loop` lors de l'intégration d'appels de fonctions asynchrones dans vos tests (par exemple en utilisant [MotorClient de MongoDB](https://stackoverflow.com/questions/41584243/runtimeerror-task-attached-to-a-different-loop)), n'oubliez pas d'instancier les objets qui ont besoin d'une boucle d'événements uniquement dans des fonctions async, par exemple dans un callback `@app.on_event("startup")`.
///
Les en-tĂȘtes du proxy sont :
-* <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/X-Forwarded-For" class="external-link" target="_blank">X-Forwarded-For</a>
-* <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/X-Forwarded-Proto" class="external-link" target="_blank">X-Forwarded-Proto</a>
-* <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/X-Forwarded-Host" class="external-link" target="_blank">X-Forwarded-Host</a>
+* [X-Forwarded-For](https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/X-Forwarded-For)
+* [X-Forwarded-Proto](https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/X-Forwarded-Proto)
+* [X-Forwarded-Host](https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/X-Forwarded-Host)
///
/// tip | Astuce
-Si vous voulez en savoir plus sur HTTPS, consultez le guide [Ă propos de HTTPS](../deployment/https.md){.internal-link target=_blank}.
+Si vous voulez en savoir plus sur HTTPS, consultez le guide [Ă propos de HTTPS](../deployment/https.md).
///
Gardez Ă l'esprit que le serveur (Uvicorn) n'utilisera ce `root_path` que pour le transmettre Ă l'application.
-Mais si vous allez avec votre navigateur sur <a href="http://127.0.0.1:8000/app" class="external-link" target="_blank">http://127.0.0.1:8000/app</a>, vous verrez la réponse normale :
+Mais si vous allez avec votre navigateur sur [http://127.0.0.1:8000/app](http://127.0.0.1:8000/app), vous verrez la réponse normale :
```JSON
{
## Tester localement avec Traefik { #testing-locally-with-traefik }
-Vous pouvez facilement faire l'expérience en local avec un préfixe de chemin supprimé en utilisant <a href="https://docs.traefik.io/" class="external-link" target="_blank">Traefik</a>.
+Vous pouvez facilement faire l'expérience en local avec un préfixe de chemin supprimé en utilisant [Traefik](https://docs.traefik.io/).
-<a href="https://github.com/containous/traefik/releases" class="external-link" target="_blank">Téléchargez Traefik</a> ; c'est un binaire unique, vous pouvez extraire le fichier compressé et l'exécuter directement depuis le terminal.
+[Téléchargez Traefik](https://github.com/containous/traefik/releases) ; c'est un binaire unique, vous pouvez extraire le fichier compressé et l'exécuter directement depuis le terminal.
Créez ensuite un fichier `traefik.toml` avec :
### Vérifier les réponses { #check-the-responses }
-Maintenant, si vous allez à l'URL avec le port pour Uvicorn : <a href="http://127.0.0.1:8000/app" class="external-link" target="_blank">http://127.0.0.1:8000/app</a>, vous verrez la réponse normale :
+Maintenant, si vous allez à l'URL avec le port pour Uvicorn : [http://127.0.0.1:8000/app](http://127.0.0.1:8000/app), vous verrez la réponse normale :
```JSON
{
///
-Et maintenant ouvrez l'URL avec le port pour Traefik, en incluant le préfixe de chemin : <a href="http://127.0.0.1:9999/api/v1/app" class="external-link" target="_blank">http://127.0.0.1:9999/api/v1/app</a>.
+Et maintenant ouvrez l'URL avec le port pour Traefik, en incluant le préfixe de chemin : [http://127.0.0.1:9999/api/v1/app](http://127.0.0.1:9999/api/v1/app).
Nous obtenons la mĂȘme rĂ©ponse :
La maniĂšre « officielle » d'accĂ©der Ă l'application serait via le proxy avec le prĂ©fixe de chemin que nous avons dĂ©fini. Donc, comme on s'y attend, si vous essayez l'interface de documentation servie directement par Uvicorn, sans le prĂ©fixe de chemin dans l'URL, cela ne fonctionne pas, car elle s'attend Ă ĂȘtre accĂ©dĂ©e via le proxy.
-Vous pouvez le vérifier sur <a href="http://127.0.0.1:8000/docs" class="external-link" target="_blank">http://127.0.0.1:8000/docs</a> :
+Vous pouvez le vérifier sur [http://127.0.0.1:8000/docs](http://127.0.0.1:8000/docs) :
<img src="/img/tutorial/behind-a-proxy/image01.png">
Mais si nous accĂ©dons Ă l'interface de documents Ă l'URL « officielle » en utilisant le proxy avec le port `9999`, Ă `/api/v1/docs`, cela fonctionne correctement ! đ
-Vous pouvez le vérifier sur <a href="http://127.0.0.1:9999/api/v1/docs" class="external-link" target="_blank">http://127.0.0.1:9999/api/v1/docs</a> :
+Vous pouvez le vérifier sur [http://127.0.0.1:9999/api/v1/docs](http://127.0.0.1:9999/api/v1/docs) :
<img src="/img/tutorial/behind-a-proxy/image02.png">
/// tip | Astuce
-Remarquez le serveur généré automatiquement avec une valeur `url` de `/api/v1`, reprise depuis le `root_path`.
+Remarquez le serveur généré automatiquement avec une valeur `url` de `/api/v1`, repris depuis le `root_path`.
///
-Dans l'interface de documents sur <a href="http://127.0.0.1:9999/api/v1/docs" class="external-link" target="_blank">http://127.0.0.1:9999/api/v1/docs</a>, cela ressemblera Ă ceci :
+Dans l'interface de documents sur [http://127.0.0.1:9999/api/v1/docs](http://127.0.0.1:9999/api/v1/docs), cela ressemblera Ă ceci :
<img src="/img/tutorial/behind-a-proxy/image03.png">
## Monter une sous-application { #mounting-a-sub-application }
-Si vous avez besoin de monter une sousâapplication (comme dĂ©crit dans [Sousâapplications - montages](sub-applications.md){.internal-link target=_blank}) tout en utilisant un proxy avec `root_path`, vous pouvez le faire normalement, comme vous vous y attendez.
+Si vous avez besoin de monter une sousâapplication (comme dĂ©crit dans [Sousâapplications - montages](sub-applications.md)) tout en utilisant un proxy avec `root_path`, vous pouvez le faire normalement, comme vous vous y attendez.
FastAPI utilisera intelligemment le `root_path` en interne, donc cela fonctionnera simplement. âš
# Réponse personnalisée - HTML, flux, fichier, autres { #custom-response-html-stream-file-others }
-Par défaut, **FastAPI** renverra les réponses en utilisant `JSONResponse`.
+Par défaut, **FastAPI** renvoie des réponses JSON.
-Vous pouvez le remplacer en renvoyant directement une `Response` comme expliqué dans [Renvoyer directement une Response](response-directly.md){.internal-link target=_blank}.
+Vous pouvez le remplacer en renvoyant une `Response` directement comme vu dans [Renvoyer une Response directement](response-directly.md).
-Mais si vous renvoyez directement une `Response` (ou n'importe quelle sous-classe, comme `JSONResponse`), les donnĂ©es ne seront pas automatiquement converties (mĂȘme si vous dĂ©clarez un `response_model`), et la documentation ne sera pas gĂ©nĂ©rĂ©e automatiquement (par exemple, l'inclusion du « media type » dans l'en-tĂȘte HTTP `Content-Type` comme partie de l'OpenAPI gĂ©nĂ©rĂ©).
+Mais si vous renvoyez directement une `Response` (ou n'importe quelle sous-classe, comme `JSONResponse`), les donnĂ©es ne seront pas automatiquement converties (mĂȘme si vous dĂ©clarez un `response_model`), et la documentation ne sera pas gĂ©nĂ©rĂ©e automatiquement (par exemple, l'inclusion du « media type », dans l'en-tĂȘte HTTP `Content-Type` comme partie de l'OpenAPI gĂ©nĂ©rĂ©).
-Vous pouvez aussi déclarer la `Response` que vous voulez utiliser (par ex. toute sous-classe de `Response`), dans le décorateur de chemin d'accÚs en utilisant le paramÚtre `response_class`.
+Vous pouvez aussi déclarer la `Response` que vous voulez utiliser (par ex. toute sous-classe de `Response`), dans le décorateur de *chemin d'accÚs* en utilisant le paramÚtre `response_class`.
-Le contenu que vous renvoyez depuis votre fonction de chemin d'accÚs sera placé à l'intérieur de cette `Response`.
-
-Et si cette `Response` a un « media type » JSON (`application/json`), comme c'est le cas avec `JSONResponse` et `UJSONResponse`, les données que vous renvoyez seront automatiquement converties (et filtrées) avec tout `response_model` Pydantic que vous avez déclaré dans le décorateur de chemin d'accÚs.
+Le contenu que vous renvoyez depuis votre *fonction de chemin d'accÚs* sera placé à l'intérieur de cette `Response`.
/// note | Remarque
-Si vous utilisez une classe de réponse sans « media type », FastAPI s'attendra à ce que votre réponse n'ait pas de contenu ; il ne documentera donc pas le format de la réponse dans les documents OpenAPI générés.
+Si vous utilisez une classe de réponse sans media type, FastAPI s'attendra à ce que votre réponse n'ait pas de contenu ; il ne documentera donc pas le format de la réponse dans la documentation OpenAPI générée.
///
-## Utiliser `ORJSONResponse` { #use-orjsonresponse }
-
-Par exemple, si vous cherchez à maximiser la performance, vous pouvez installer et utiliser <a href="https://github.com/ijl/orjson" class="external-link" target="_blank">`orjson`</a> et définir la réponse sur `ORJSONResponse`.
-
-Importez la classe (sous-classe) `Response` que vous voulez utiliser et déclarez-la dans le décorateur de chemin d'accÚs.
-
-Pour de grandes réponses, renvoyer directement une `Response` est bien plus rapide que de renvoyer un dictionnaire.
-
-Cela vient du fait que, par dĂ©faut, FastAPI inspectera chaque Ă©lĂ©ment et s'assurera qu'il est sĂ©rialisable en JSON, en utilisant le mĂȘme [Encodeur compatible JSON](../tutorial/encoder.md){.internal-link target=_blank} expliquĂ© dans le didacticiel. C'est ce qui vous permet de renvoyer des objets arbitraires, par exemple des modĂšles de base de donnĂ©es.
-
-Mais si vous ĂȘtes certain que le contenu que vous renvoyez est sĂ©rialisable en JSON, vous pouvez le passer directement Ă la classe de rĂ©ponse et Ă©viter le surcoĂ»t supplĂ©mentaire qu'aurait FastAPI en faisant passer votre contenu de retour par le `jsonable_encoder` avant de le transmettre Ă la classe de rĂ©ponse.
+## RĂ©ponses JSON { #json-responses }
-{* ../../docs_src/custom_response/tutorial001b_py310.py hl[2,7] *}
+Par défaut, FastAPI renvoie des réponses JSON.
-/// info
-
-Le paramÚtre `response_class` sera aussi utilisé pour définir le « media type » de la réponse.
+Si vous déclarez un [ModÚle de réponse](../tutorial/response-model.md), FastAPI l'utilisera pour sérialiser les données en JSON, en utilisant Pydantic.
-Dans ce cas, l'en-tĂȘte HTTP `Content-Type` sera dĂ©fini Ă `application/json`.
+Si vous ne déclarez pas de modÚle de réponse, FastAPI utilisera le `jsonable_encoder` expliqué dans [Encodeur compatible JSON](../tutorial/encoder.md) et le placera dans une `JSONResponse`.
-Et il sera documenté comme tel dans OpenAPI.
+Si vous déclarez une `response_class` avec un media type JSON (`application/json`), comme c'est le cas avec `JSONResponse`, les données que vous renvoyez seront automatiquement converties (et filtrées) avec tout `response_model` Pydantic que vous avez déclaré dans le décorateur de *chemin d'accÚs*. Mais les données ne seront pas sérialisées en octets JSON avec Pydantic, elles seront converties avec le `jsonable_encoder` puis passées à la classe `JSONResponse`, qui les sérialisera en octets en utilisant la bibliothÚque JSON standard de Python.
-///
+### Performance JSON { #json-performance }
-/// tip | Astuce
+En bref, si vous voulez la performance maximale, utilisez un [ModÚle de réponse](../tutorial/response-model.md) et ne déclarez pas de `response_class` dans le décorateur de *chemin d'accÚs*.
-`ORJSONResponse` est disponible uniquement dans FastAPI, pas dans Starlette.
-
-///
+{* ../../docs_src/response_model/tutorial001_01_py310.py ln[15:17] hl[16] *}
## RĂ©ponse HTML { #html-response }
Pour renvoyer une réponse avec du HTML directement depuis **FastAPI**, utilisez `HTMLResponse`.
- Importez `HTMLResponse`.
-- Passez `HTMLResponse` comme paramÚtre `response_class` de votre décorateur de chemin d'accÚs.
+- Passez `HTMLResponse` comme paramÚtre `response_class` de votre *décorateur de chemin d'accÚs*.
{* ../../docs_src/custom_response/tutorial002_py310.py hl[2,7] *}
### Renvoyer une `Response` { #return-a-response }
-Comme vu dans [Renvoyer directement une Response](response-directly.md){.internal-link target=_blank}, vous pouvez aussi remplacer la réponse directement dans votre chemin d'accÚs, en la renvoyant.
+Comme vu dans [Renvoyer une Response directement](response-directly.md), vous pouvez aussi remplacer la réponse directement dans votre *chemin d'accÚs*, en la renvoyant.
Le mĂȘme exemple ci-dessus, renvoyant une `HTMLResponse`, pourrait ressembler Ă :
/// warning | Alertes
-Une `Response` renvoyée directement par votre fonction de chemin d'accÚs ne sera pas documentée dans OpenAPI (par exemple, le `Content-Type` ne sera pas documenté) et ne sera pas visible dans les documents interactifs automatiques.
+Une `Response` renvoyée directement par votre *fonction de chemin d'accÚs* ne sera pas documentée dans OpenAPI (par exemple, le `Content-Type` ne sera pas documenté) et ne sera pas visible dans les documents interactifs automatiques.
///
Si vous voulez remplacer la rĂ©ponse depuis l'intĂ©rieur de la fonction mais en mĂȘme temps documenter le « media type » dans OpenAPI, vous pouvez utiliser le paramĂštre `response_class` ET renvoyer un objet `Response`.
-`response_class` sera alors utilisé uniquement pour documenter l'opération de chemin d'accÚs OpenAPI, mais votre `Response` sera utilisée telle quelle.
+`response_class` sera alors utilisĂ© uniquement pour documenter lâ*opĂ©ration de chemin d'accĂšs* OpenAPI, mais votre `Response` sera utilisĂ©e telle quelle.
#### Renvoyer directement une `HTMLResponse` { #return-an-htmlresponse-directly }
### `HTMLResponse` { #htmlresponse }
-Prend du texte ou des octets et renvoie une réponse HTML, comme vous l'avez lu ci-dessus.
+Prend du texte ou des octets et renvoie une réponse HTML, comme vous l'avez vu ci-dessus.
### `PlainTextResponse` { #plaintextresponse }
C'est la réponse par défaut utilisée dans **FastAPI**, comme vous l'avez lu ci-dessus.
-### `ORJSONResponse` { #orjsonresponse }
-
-Une réponse JSON alternative rapide utilisant <a href="https://github.com/ijl/orjson" class="external-link" target="_blank">`orjson`</a>, comme vous l'avez lu ci-dessus.
-
-/// info
-
-Cela nécessite l'installation de `orjson`, par exemple avec `pip install orjson`.
-
-///
-
-### `UJSONResponse` { #ujsonresponse }
-
-Une réponse JSON alternative utilisant <a href="https://github.com/ultrajson/ultrajson" class="external-link" target="_blank">`ujson`</a>.
-
-/// info
-
-Cela nécessite l'installation de `ujson`, par exemple avec `pip install ujson`.
-
-///
-
-/// warning | Alertes
-
-`ujson` est moins rigoureux que l'implémentation intégrée de Python dans sa gestion de certains cas limites.
-
-///
-
-{* ../../docs_src/custom_response/tutorial001_py310.py hl[2,7] *}
+/// note | DĂ©tails techniques
-/// tip | Astuce
+Mais si vous déclarez un modÚle de réponse ou un type de retour, il sera utilisé directement pour sérialiser les données en JSON, et une réponse avec le bon media type pour JSON sera renvoyée directement, sans utiliser la classe `JSONResponse`.
-Il est possible que `ORJSONResponse` soit une alternative plus rapide.
+C'est la maniÚre idéale d'obtenir la meilleure performance.
///
{* ../../docs_src/custom_response/tutorial006b_py310.py hl[2,7,9] *}
-Si vous faites cela, vous pouvez alors renvoyer directement l'URL depuis votre fonction de chemin d'accĂšs.
+Si vous faites cela, vous pouvez alors renvoyer directement l'URL depuis votre *fonction de chemin d'accĂšs*.
Dans ce cas, le `status_code` utilisé sera celui par défaut pour `RedirectResponse`, c'est-à -dire `307`.
### `StreamingResponse` { #streamingresponse }
-Prend un générateur async ou un générateur/itérateur normal et diffuse le corps de la réponse.
-
-{* ../../docs_src/custom_response/tutorial007_py310.py hl[2,14] *}
-
-#### Utiliser `StreamingResponse` avec des objets de type fichier { #using-streamingresponse-with-file-like-objects }
+Prend un générateur async ou un générateur/itérateur normal (une fonction avec `yield`) et diffuse le corps de la réponse.
-Si vous avez un objet <a href="https://docs.python.org/3/glossary.html#term-file-like-object" class="external-link" target="_blank">de type fichier</a> (par ex. l'objet renvoyé par `open()`), vous pouvez créer une fonction génératrice pour itérer sur cet objet de type fichier.
+{* ../../docs_src/custom_response/tutorial007_py310.py hl[3,16] *}
-De cette façon, vous n'avez pas à tout lire en mémoire au préalable, et vous pouvez passer cette fonction génératrice à `StreamingResponse`, puis la renvoyer.
-
-Cela inclut de nombreuses bibliothÚques pour interagir avec du stockage cloud, du traitement vidéo, et autres.
+/// note | DĂ©tails techniques
-{* ../../docs_src/custom_response/tutorial008_py310.py hl[2,10:12,14] *}
+Une tĂąche `async` ne peut ĂȘtre annulĂ©e que lorsqu'elle atteint un `await`. S'il n'y a pas de `await`, le gĂ©nĂ©rateur (fonction avec `yield`) ne peut pas ĂȘtre annulĂ© correctement et peut continuer Ă s'exĂ©cuter mĂȘme aprĂšs la demande d'annulation.
-1. C'est la fonction génératrice. C'est une « fonction génératrice » parce qu'elle contient des instructions `yield` à l'intérieur.
-2. En utilisant un bloc `with`, nous nous assurons que l'objet de type fichier est fermé aprÚs l'exécution de la fonction génératrice. Donc, aprÚs qu'elle a fini d'envoyer la réponse.
-3. Ce `yield from` indique à la fonction d'itérer sur l'objet nommé `file_like`. Puis, pour chaque partie itérée, de produire cette partie comme provenant de cette fonction génératrice (`iterfile`).
+Comme ce petit exemple n'a besoin d'aucune instruction `await`, nous ajoutons un `await anyio.sleep(0)` pour donner une chance à la boucle d'événements de gérer l'annulation.
- Ainsi, c'est une fonction génératrice qui transfÚre le travail de « génération » à autre chose en interne.
+Cela serait encore plus important avec des flux volumineux ou infinis.
- En procédant ainsi, nous pouvons la placer dans un bloc `with` et, de cette façon, garantir que l'objet de type fichier est fermé aprÚs la fin.
+///
/// tip | Astuce
-Remarquez qu'ici, comme nous utilisons le `open()` standard qui ne prend pas en charge `async` et `await`, nous déclarons le chemin d'accÚs avec un `def` normal.
+Au lieu de renvoyer une `StreamingResponse` directement, vous devriez probablement suivre le style de [Diffuser des données](./stream-data.md), c'est beaucoup plus pratique et gÚre l'annulation en arriÚre-plan pour vous.
+
+Si vous diffusez des JSON Lines, suivez le didacticiel [Diffuser des JSON Lines](../tutorial/stream-json-lines.md).
///
{* ../../docs_src/custom_response/tutorial009b_py310.py hl[2,8,10] *}
-Dans ce cas, vous pouvez renvoyer directement le chemin du fichier depuis votre fonction de chemin d'accĂšs.
+Dans ce cas, vous pouvez renvoyer directement le chemin du fichier depuis votre *fonction de chemin d'accĂšs*.
## Classe de réponse personnalisée { #custom-response-class }
Vous pouvez créer votre propre classe de réponse personnalisée, héritant de `Response`, et l'utiliser.
-Par exemple, disons que vous voulez utiliser <a href="https://github.com/ijl/orjson" class="external-link" target="_blank">`orjson`</a>, mais avec certains réglages personnalisés non utilisés dans la classe `ORJSONResponse` incluse.
+Par exemple, disons que vous voulez utiliser [`orjson`](https://github.com/ijl/orjson) avec certains réglages.
Disons que vous voulez renvoyer du JSON indenté et formaté, donc vous voulez utiliser l'option orjson `orjson.OPT_INDENT_2`.
Bien sĂ»r, vous trouverez probablement des moyens bien meilleurs de tirer parti de cela que de formater du JSON. đ
+### `orjson` ou ModÚle de réponse { #orjson-or-response-model }
+
+Si ce que vous recherchez est la performance, vous aurez probablement de meilleurs résultats en utilisant un [ModÚle de réponse](../tutorial/response-model.md) qu'une réponse `orjson`.
+
+Avec un modÚle de réponse, FastAPI utilisera Pydantic pour sérialiser les données en JSON, sans étapes intermédiaires, comme la conversion avec `jsonable_encoder`, qui se produirait dans tout autre cas.
+
+Et en interne, Pydantic utilise les mĂȘmes mĂ©canismes Rust sous-jacents que `orjson` pour sĂ©rialiser en JSON, vous obtiendrez donc dĂ©jĂ la meilleure performance avec un modĂšle de rĂ©ponse.
+
## Classe de réponse par défaut { #default-response-class }
Lors de la création d'une instance de classe **FastAPI** ou d'un `APIRouter`, vous pouvez spécifier quelle classe de réponse utiliser par défaut.
Le paramÚtre qui le définit est `default_response_class`.
-Dans l'exemple ci-dessous, **FastAPI** utilisera `ORJSONResponse` par défaut, dans tous les chemins d'accÚs, au lieu de `JSONResponse`.
+Dans l'exemple ci-dessous, **FastAPI** utilisera `HTMLResponse` par défaut, dans tous les *chemins d'accÚs*, au lieu de JSON.
{* ../../docs_src/custom_response/tutorial010_py310.py hl[2,4] *}
/// tip | Astuce
-Vous pouvez toujours remplacer `response_class` dans les chemins d'accĂšs comme auparavant.
+Vous pouvez toujours remplacer `response_class` dans les *chemins d'accĂšs* comme auparavant.
///
## Documentation supplémentaire { #additional-documentation }
-Vous pouvez aussi déclarer le media type et de nombreux autres détails dans OpenAPI en utilisant `responses` : [Réponses supplémentaires dans OpenAPI](additional-responses.md){.internal-link target=_blank}.
+Vous pouvez aussi déclarer le media type et de nombreux autres détails dans OpenAPI en utilisant `responses` : [Réponses supplémentaires dans OpenAPI](additional-responses.md).
FastAPI est construit auâdessus de **Pydantic**, et je vous ai montrĂ© comment utiliser des modĂšles Pydantic pour dĂ©clarer les requĂȘtes et les rĂ©ponses.
-Mais FastAPI prend aussi en charge l'utilisation de <a href="https://docs.python.org/3/library/dataclasses.html" class="external-link" target="_blank">`dataclasses`</a> de la mĂȘme maniĂšre :
+Mais FastAPI prend aussi en charge l'utilisation de [`dataclasses`](https://docs.python.org/3/library/dataclasses.html) de la mĂȘme maniĂšre :
{* ../../docs_src/dataclasses_/tutorial001_py310.py hl[1,6:11,18:19] *}
-Cela fonctionne grĂące Ă **Pydantic**, qui offre une <a href="https://docs.pydantic.dev/latest/concepts/dataclasses/#use-of-stdlib-dataclasses-with-basemodel" class="external-link" target="_blank">prise en charge interne des `dataclasses`</a>.
+Cela fonctionne grĂące Ă **Pydantic**, qui offre une [prise en charge interne des `dataclasses`](https://docs.pydantic.dev/latest/concepts/dataclasses/#use-of-stdlib-dataclasses-with-basemodel).
Ainsi, mĂȘme avec le code ciâdessus qui n'emploie pas explicitement Pydantic, FastAPI utilise Pydantic pour convertir ces dataclasses standard en la variante de dataclasses de Pydantic.
Cela fonctionne de la mĂȘme maniĂšre qu'avec les modĂšles Pydantic. Et, en rĂ©alitĂ©, c'est mis en Ćuvre de la mĂȘme façon en interne, en utilisant Pydantic.
-/// info | Info
+/// info
Gardez Ă l'esprit que les dataclasses ne peuvent pas tout ce que peuvent faire les modĂšles Pydantic.
Comme toujours, avec FastAPI vous pouvez combiner `def` et `async def` selon vos besoins.
- Si vous avez besoin d'un rappel sur quand utiliser l'un ou l'autre, consultez la section _« In a hurry? »_ dans la documentation à propos de [`async` et `await`](../async.md#in-a-hurry){.internal-link target=_blank}.
+ Si vous avez besoin d'un rappel sur quand utiliser l'un ou l'autre, consultez la section _« In a hurry? »_ dans la documentation à propos de [`async` et `await`](../async.md#in-a-hurry).
9. Cette *fonction de chemin d'accĂšs* ne renvoie pas des dataclasses (mĂȘme si elle le pourrait), mais une liste de dictionnaires contenant des donnĂ©es internes.
Vous pouvez aussi combiner `dataclasses` avec d'autres modÚles Pydantic, en hériter, les inclure dans vos propres modÚles, etc.
-Pour en savoir plus, consultez la <a href="https://docs.pydantic.dev/latest/concepts/dataclasses/" class="external-link" target="_blank">documentation Pydantic sur les dataclasses</a>.
+Pour en savoir plus, consultez la [documentation Pydantic sur les dataclasses](https://docs.pydantic.dev/latest/concepts/dataclasses/).
## Version { #version }
/// tip | Astuce
-Lâ« arrĂȘt » se produit lorsque vous **arrĂȘtez** l'application.
+Le `shutdown` se produit lorsque vous **arrĂȘtez** l'application.
Peut-ĂȘtre devez-vous dĂ©marrer une nouvelle version, ou vous en avez simplement assez de l'exĂ©cuter. đ€·
Juste un dĂ©tail technique pour les nerds curieux. đ€
-Sous le capot, dans la spécification technique ASGI, cela fait partie du <a href="https://asgi.readthedocs.io/en/latest/specs/lifespan.html" class="external-link" target="_blank">protocole Lifespan</a>, et il y définit des événements appelés `startup` et `shutdown`.
+Sous le capot, dans la spécification technique ASGI, cela fait partie du [protocole Lifespan](https://asgi.readthedocs.io/en/latest/specs/lifespan.html), et il y définit des événements appelés `startup` et `shutdown`.
/// info
-Vous pouvez en lire plus sur les gestionnaires `lifespan` de Starlette dans la <a href="https://www.starlette.dev/lifespan/" class="external-link" target="_blank">documentation « Lifespan » de Starlette</a>.
+Vous pouvez en lire plus sur les gestionnaires `lifespan` de Starlette dans la [documentation « Lifespan » de Starlette](https://www.starlette.dev/lifespan/).
Y compris comment gĂ©rer l'Ă©tat de cycle de vie qui peut ĂȘtre utilisĂ© dans d'autres parties de votre code.
## Sous-applications { #sub-applications }
-đš Gardez Ă l'esprit que ces Ă©vĂ©nements de cycle de vie (dĂ©marrage et arrĂȘt) ne seront exĂ©cutĂ©s que pour l'application principale, pas pour [Sous-applications - Montages](sub-applications.md){.internal-link target=_blank}.
+đš Gardez Ă l'esprit que ces Ă©vĂ©nements de cycle de vie (dĂ©marrage et arrĂȘt) ne seront exĂ©cutĂ©s que pour l'application principale, pas pour [Sous-applications - Montages](sub-applications.md).
## Générateurs de SDK open source { #open-source-sdk-generators }
-Une option polyvalente est <a href="https://openapi-generator.tech/" class="external-link" target="_blank">OpenAPI Generator</a>, qui prend en charge **de nombreux langages de programmation** et peut générer des SDK à partir de votre spécification OpenAPI.
+Une option polyvalente est le [OpenAPI Generator](https://openapi-generator.tech/), qui prend en charge **de nombreux langages de programmation** et peut générer des SDK à partir de votre spécification OpenAPI.
-Pour les **clients TypeScript**, <a href="https://heyapi.dev/" class="external-link" target="_blank">Hey API</a> est une solution dĂ©diĂ©e, offrant une expĂ©rience optimisĂ©e pour lâĂ©cosystĂšme TypeScript.
+Pour les **clients TypeScript**, [Hey API](https://heyapi.dev/) est une solution dĂ©diĂ©e, offrant une expĂ©rience optimisĂ©e pour lâĂ©cosystĂšme TypeScript.
-Vous pouvez découvrir davantage de générateurs de SDK sur <a href="https://openapi.tools/#sdk" class="external-link" target="_blank">OpenAPI.Tools</a>.
+Vous pouvez découvrir davantage de générateurs de SDK sur [OpenAPI.Tools](https://openapi.tools/#sdk).
/// tip | Astuce
Cette section met en avant des solutions **soutenues par des fonds** et **par des entreprises** qui sponsorisent FastAPI. Ces produits offrent **des fonctionnalités supplémentaires** et **des intégrations** en plus de SDK de haute qualité générés.
-En âš [**sponsorisant FastAPI**](../help-fastapi.md#sponsor-the-author){.internal-link target=_blank} âš, ces entreprises contribuent Ă garantir que le framework et son **Ă©cosystĂšme** restent sains et **durables**.
+En âš [**sponsorisant FastAPI**](../help-fastapi.md#sponsor-the-author) âš, ces entreprises contribuent Ă garantir que le framework et son **Ă©cosystĂšme** restent sains et **durables**.
Leur sponsoring dĂ©montre Ă©galement un fort engagement envers la **communautĂ©** FastAPI (vous), montrant quâelles se soucient non seulement dâoffrir un **excellent service**, mais aussi de soutenir un **framework robuste et florissant**, FastAPI. đ
Par exemple, vous pourriez essayer :
-* <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>
+* [Speakeasy](https://speakeasy.com/editor?utm_source=fastapi+repo&utm_medium=github+sponsorship)
+* [Stainless](https://www.stainless.com/?utm_source=fastapi&utm_medium=referral)
+* [liblab](https://developers.liblab.com/tutorials/sdk-for-fastapi?utm_source=fastapi)
Certaines de ces solutions peuvent aussi ĂȘtre open source ou proposer des niveaux gratuits, afin que vous puissiez les essayer sans engagement financier. Dâautres gĂ©nĂ©rateurs de SDK commerciaux existent et peuvent ĂȘtre trouvĂ©s en ligne. đ€
Cela générera un SDK TypeScript dans `./src/client`.
-Vous pouvez apprendre à <a href="https://heyapi.dev/openapi-ts/get-started" class="external-link" target="_blank">installer `@hey-api/openapi-ts`</a> et lire à propos du <a href="https://heyapi.dev/openapi-ts/output" class="external-link" target="_blank">résultat généré</a> sur leur site.
+Vous pouvez apprendre à [installer `@hey-api/openapi-ts`](https://heyapi.dev/openapi-ts/get-started) et lire à propos du [résultat généré](https://heyapi.dev/openapi-ts/output) sur leur site.
### Utiliser le SDK { #using-the-sdk }
## Caractéristiques supplémentaires { #additional-features }
-Le [Tutoriel - Guide de l'utilisateur](../tutorial/index.md){.internal-link target=_blank} devrait suffire à vous faire découvrir toutes les fonctionnalités principales de **FastAPI**.
+Le [Tutoriel - Guide de l'utilisateur](../tutorial/index.md) devrait suffire à vous faire découvrir toutes les fonctionnalités principales de **FastAPI**.
Dans les sections suivantes, vous verrez des options, configurations et fonctionnalités supplémentaires.
## Lire d'abord le tutoriel { #read-the-tutorial-first }
-Vous pouvez utiliser la plupart des fonctionnalités de **FastAPI** grùce aux connaissances du [Tutoriel - Guide de l'utilisateur](../tutorial/index.md){.internal-link target=_blank}.
+Vous pouvez utiliser la plupart des fonctionnalités de **FastAPI** grùce aux connaissances du [Tutoriel - Guide de l'utilisateur](../tutorial/index.md).
Et les sections suivantes supposent que vous l'avez lu et que vous en connaissez les idées principales.
# Utiliser des middlewares avancés { #advanced-middleware }
-Dans le tutoriel principal, vous avez vu comment ajouter des [middlewares personnalisés](../tutorial/middleware.md){.internal-link target=_blank} à votre application.
+Dans le tutoriel principal, vous avez vu comment ajouter des [middlewares personnalisés](../tutorial/middleware.md) à votre application.
-Vous avez également vu comment gérer [CORS avec le `CORSMiddleware`](../tutorial/cors.md){.internal-link target=_blank}.
+Vous avez également vu comment gérer [CORS avec le `CORSMiddleware`](../tutorial/cors.md).
Dans cette section, nous allons voir comment utiliser d'autres middlewares.
Par exemple :
-- <a href="https://github.com/encode/uvicorn/blob/master/uvicorn/middleware/proxy_headers.py" class="external-link" target="_blank">Le `ProxyHeadersMiddleware` d'Uvicorn</a>
-- <a href="https://github.com/florimondmanca/msgpack-asgi" class="external-link" target="_blank">MessagePack</a>
+- [Le `ProxyHeadersMiddleware` d'Uvicorn](https://github.com/encode/uvicorn/blob/master/uvicorn/middleware/proxy_headers.py)
+- [MessagePack](https://github.com/florimondmanca/msgpack-asgi)
-Pour voir d'autres middlewares disponibles, consultez <a href="https://www.starlette.dev/middleware/" class="external-link" target="_blank">la documentation des middlewares de Starlette</a> et la <a href="https://github.com/florimondmanca/awesome-asgi" class="external-link" target="_blank">liste ASGI Awesome</a>.
+Pour voir d'autres middlewares disponibles, consultez la [documentation des middlewares de Starlette](https://www.starlette.dev/middleware/) et la [liste ASGI Awesome](https://github.com/florimondmanca/awesome-asgi).
/// tip | Astuce
-Le paramĂštre de requĂȘte `callback_url` utilise un type Pydantic <a href="https://docs.pydantic.dev/latest/api/networks/" class="external-link" target="_blank">Url</a>.
+Le paramĂštre de requĂȘte `callback_url` utilise un type Pydantic [Url](https://docs.pydantic.dev/latest/api/networks/).
///
Le callback rĂ©el nâest quâune requĂȘte HTTP.
-En implĂ©mentant vous-mĂȘme le callback, vous pourriez utiliser quelque chose comme <a href="https://www.python-httpx.org" class="external-link" target="_blank">HTTPX</a> ou <a href="https://requests.readthedocs.io/" class="external-link" target="_blank">Requests</a>.
+En implĂ©mentant vous-mĂȘme le callback, vous pourriez utiliser quelque chose comme [HTTPX](https://www.python-httpx.org) ou [Requests](https://requests.readthedocs.io/).
///
Il y a 2 principales différences par rapport à un *chemin d'accÚs* normal :
* Il nâa pas besoin dâavoir de code rĂ©el, car votre application nâappellera jamais ce code. Il sert uniquement Ă documenter lâ*API externe*. La fonction peut donc simplement contenir `pass`.
-* Le *chemin* peut contenir une <a href="https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md#key-expression" class="external-link" target="_blank">expression OpenAPI 3</a> (voir plus bas) oĂč il peut utiliser des variables avec des paramĂštres et des parties de la requĂȘte originale envoyĂ©e Ă *votre API*.
+* Le *chemin* peut contenir une [expression OpenAPI 3](https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md#key-expression) (voir plus bas) oĂč il peut utiliser des variables avec des paramĂštres et des parties de la requĂȘte originale envoyĂ©e Ă *votre API*.
### Lâexpression du chemin de callback { #the-callback-path-expression }
-Le *chemin* du callback peut contenir une <a href="https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md#key-expression" class="external-link" target="_blank">expression OpenAPI 3</a> qui peut inclure des parties de la requĂȘte originale envoyĂ©e Ă *votre API*.
+Le *chemin* du callback peut contenir une [expression OpenAPI 3](https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md#key-expression) qui peut inclure des parties de la requĂȘte originale envoyĂ©e Ă *votre API*.
Dans ce cas, câest la `str`Â :
### VĂ©rifier la documentation { #check-the-docs }
-Vous pouvez maintenant démarrer votre application et aller sur <a href="http://127.0.0.1:8000/docs" class="external-link" target="_blank">http://127.0.0.1:8000/docs</a>.
+Vous pouvez maintenant démarrer votre application et aller sur [http://127.0.0.1:8000/docs](http://127.0.0.1:8000/docs).
Vous verrez votre documentation incluant une section « Callbacks » pour votre *chemin d'accĂšs* qui montre Ă quoi lâ*API externe* devrait ressembler :
{* ../../docs_src/openapi_webhooks/tutorial001_py310.py hl[9:12,15:20] *}
-Les webhooks que vous définissez apparaßtront dans le schéma **OpenAPI** et dans l'interface de **documentation** automatique.
+Les webhooks que vous définissez apparaßtront dans le schéma OpenAPI et dans l'interface de documentation automatique.
/// info
### Consulter la documentation { #check-the-docs }
-Vous pouvez maintenant démarrer votre application et aller sur <a href="http://127.0.0.1:8000/docs" class="external-link" target="_blank">http://127.0.0.1:8000/docs</a>.
+Vous pouvez maintenant démarrer votre application et aller sur [http://127.0.0.1:8000/docs](http://127.0.0.1:8000/docs).
Vous verrez que votre documentation contient les chemins d'accÚs habituels et désormais aussi des webhooks :
Vous pouvez limiter les lignes utilisĂ©es de la docstring dâune fonction de chemin dâaccĂšs pour OpenAPI.
-Lâajout dâun `\f` (un caractĂšre « saut de page » Ă©chappĂ©) amĂšne **FastAPI** Ă tronquer la sortie utilisĂ©e pour OpenAPI Ă cet endroit.
+Lâajout dâun `\f` (un caractĂšre « form feed » Ă©chappĂ©) amĂšne **FastAPI** Ă tronquer la sortie utilisĂ©e pour OpenAPI Ă cet endroit.
Cela nâapparaĂźtra pas dans la documentation, mais dâautres outils (comme Sphinx) pourront utiliser le reste.
Vous pouvez également déclarer des réponses supplémentaires avec leurs modÚles, codes de statut, etc.
-Il y a un chapitre entier dans la documentation à ce sujet, vous pouvez le lire dans [Réponses supplémentaires dans OpenAPI](additional-responses.md){.internal-link target=_blank}.
+Il y a un chapitre entier dans la documentation à ce sujet, vous pouvez le lire dans [Réponses supplémentaires dans OpenAPI](additional-responses.md).
## OpenAPI supplémentaire { #openapi-extra }
/// note | DĂ©tails techniques
-Dans la spĂ©cification OpenAPI, cela sâappelle lâ<a href="https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.3.md#operation-object" class="external-link" target="_blank">objet Operation</a>.
+Dans la spĂ©cification OpenAPI, cela sâappelle lâ[objet Operation](https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.3.md#operation-object).
///
Ceci est un point dâextension de bas niveau.
-Si vous avez seulement besoin de dĂ©clarer des rĂ©ponses supplĂ©mentaires, un moyen plus pratique de le faire est dâutiliser [RĂ©ponses supplĂ©mentaires dans OpenAPI](additional-responses.md){.internal-link target=_blank}.
+Si vous avez seulement besoin de dĂ©clarer des rĂ©ponses supplĂ©mentaires, un moyen plus pratique de le faire est dâutiliser [RĂ©ponses supplĂ©mentaires dans OpenAPI](additional-responses.md).
///
# RĂ©ponse - Modifier le code d'Ă©tat { #response-change-status-code }
-Vous avez probablement déjà lu que vous pouvez définir un [Code d'état de la réponse](../tutorial/response-status-code.md){.internal-link target=_blank} par défaut.
+Vous avez probablement déjà lu que vous pouvez définir un [Code d'état de la réponse](../tutorial/response-status-code.md) par défaut.
Mais dans certains cas, vous devez renvoyer un code d'état différent de celui par défaut.
## Utiliser un paramĂštre `Response` { #use-a-response-parameter }
-Vous pouvez déclarer un paramÚtre de type `Response` dans votre fonction de chemin d'accÚs.
+Vous pouvez déclarer un paramÚtre de type `Response` dans votre *fonction de chemin d'accÚs*.
Vous pouvez ensuite définir des cookies dans cet objet de réponse *temporaire*.
Vous pouvez également créer des cookies en renvoyant une `Response` directement dans votre code.
-Pour ce faire, vous pouvez créer une réponse comme décrit dans [Renvoyer une Response directement](response-directly.md){.internal-link target=_blank}.
+Pour ce faire, vous pouvez créer une réponse comme décrit dans [Renvoyer une Response directement](response-directly.md).
DĂ©finissez ensuite des cookies dessus, puis renvoyez-la :
///
-Pour voir tous les paramĂštres et options disponibles, consultez la <a href="https://www.starlette.dev/responses/#set-cookie" class="external-link" target="_blank">documentation de Starlette</a>.
+Pour voir tous les paramĂštres et options disponibles, consultez la [documentation de Starlette](https://www.starlette.dev/responses/#set-cookie).
# Renvoyer directement une réponse { #return-a-response-directly }
-Lorsque vous créez un *chemin d'accÚs* **FastAPI**, vous pouvez normalement retourner n'importe quelle donnée : un `dict`, une `list`, un modÚle Pydantic, un modÚle de base de données, etc.
+Lorsque vous créez un *chemin d'accÚs* **FastAPI**, vous pouvez normalement renvoyer n'importe quelle donnée : un `dict`, une `list`, un modÚle Pydantic, un modÚle de base de données, etc.
-Par défaut, **FastAPI** convertirait automatiquement cette valeur de retour en JSON en utilisant le `jsonable_encoder` expliqué dans [Encodeur compatible JSON](../tutorial/encoder.md){.internal-link target=_blank}.
+Si vous déclarez un [ModÚle de réponse](../tutorial/response-model.md), FastAPI l'utilise pour sérialiser les données en JSON, en utilisant Pydantic.
-Ensuite, en arriÚre-plan, il mettra ces données JSON-compatible (par exemple un `dict`) à l'intérieur d'un `JSONResponse` qui sera utilisé pour envoyer la réponse au client.
+Si vous ne déclarez pas de modÚle de réponse, FastAPI utilise le `jsonable_encoder` expliqué dans [Encodeur compatible JSON](../tutorial/encoder.md) et le place dans une `JSONResponse`.
-Mais vous pouvez retourner une `JSONResponse` directement Ă partir de vos *chemins d'accĂšs*.
+Vous pouvez également créer directement une `JSONResponse` et la renvoyer.
-Cela peut ĂȘtre utile, par exemple, pour retourner des en-tĂȘtes personnalisĂ©s ou des cookies.
+/// tip | Astuce
+
+Vous aurez normalement une bien meilleure performance en utilisant un [ModÚle de réponse](../tutorial/response-model.md) qu'en renvoyant directement une `JSONResponse`, car de cette façon la sérialisation des données est effectuée par Pydantic, en Rust.
+
+///
## Renvoyer une `Response` { #return-a-response }
-En fait, vous pouvez retourner n'importe quelle `Response` ou n'importe quelle sous-classe de celle-ci.
+Vous pouvez renvoyer une `Response` ou n'importe laquelle de ses sous-classes.
-/// tip | Astuce
+/// info
`JSONResponse` est elle-mĂȘme une sous-classe de `Response`.
///
-Et quand vous retournez une `Response`, **FastAPI** la transmet directement.
+Et lorsque vous renvoyez une `Response`, **FastAPI** la transmet directement.
+
+Il n'effectue aucune conversion de données avec les modÚles Pydantic, il ne convertit pas le contenu en un autre type, etc.
-Elle ne fera aucune conversion de données avec les modÚles Pydantic, elle ne convertira pas le contenu en un type quelconque, etc.
+Cela vous donne beaucoup de flexibilité. Vous pouvez renvoyer n'importe quel type de données, surcharger toute déclaration ou validation de données, etc.
-Cela vous donne beaucoup de flexibilité. Vous pouvez retourner n'importe quel type de données, surcharger n'importe quelle déclaration ou validation de données, etc.
+Cela vous donne aussi beaucoup de responsabilitĂ©. Vous devez vous assurer que les donnĂ©es que vous renvoyez sont correctes, dans le bon format, qu'elles peuvent ĂȘtre sĂ©rialisĂ©es, etc.
## Utiliser le `jsonable_encoder` dans une `Response` { #using-the-jsonable-encoder-in-a-response }
-Parce que **FastAPI** n'apporte aucune modification Ă une `Response` que vous retournez, vous devez vous assurer que son contenu est prĂȘt pour cela.
+Comme **FastAPI** n'apporte aucune modification Ă une `Response` que vous renvoyez, vous devez vous assurer que son contenu est prĂȘt pour cela.
-Par exemple, vous ne pouvez pas mettre un modÚle Pydantic dans une `JSONResponse` sans d'abord le convertir en un `dict` avec tous les types de données (comme `datetime`, `UUID`, etc.) convertis en types compatibles avec JSON.
+Par exemple, vous ne pouvez pas mettre un modÚle Pydantic dans une `JSONResponse` sans d'abord le convertir en un `dict` avec tous les types de données (comme `datetime`, `UUID`, etc.) convertis en types compatibles JSON.
Pour ces cas, vous pouvez utiliser le `jsonable_encoder` pour convertir vos données avant de les passer à une réponse :
Vous pouvez aussi utiliser `from starlette.responses import JSONResponse`.
-**FastAPI** fournit le mĂȘme `starlette.responses` que `fastapi.responses` juste par commoditĂ© pour vous, le dĂ©veloppeur. Mais la plupart des rĂ©ponses disponibles proviennent directement de Starlette.
+**FastAPI** fournit le mĂȘme `starlette.responses` que `fastapi.responses` uniquement par commoditĂ© pour vous, dĂ©veloppeur. Mais la plupart des rĂ©ponses disponibles proviennent directement de Starlette.
///
## Renvoyer une `Response` personnalisée { #returning-a-custom-response }
-L'exemple ci-dessus montre toutes les parties dont vous avez besoin, mais il n'est pas encore trÚs utile, car vous auriez pu retourner l'`item` directement, et **FastAPI** l'aurait mis dans une `JSONResponse` pour vous, en le convertissant en `dict`, etc. Tout cela par défaut.
+L'exemple ci-dessus montre toutes les parties dont vous avez besoin, mais il n'est pas encore trÚs utile, car vous auriez pu renvoyer l'`item` directement, et **FastAPI** l'aurait placé dans une `JSONResponse` pour vous, en le convertissant en `dict`, etc. Tout cela par défaut.
-Maintenant, voyons comment vous pourriez utiliser cela pour retourner une réponse personnalisée.
+Voyons maintenant comment vous pourriez utiliser cela pour renvoyer une réponse personnalisée.
-Disons que vous voulez retourner une réponse <a href="https://en.wikipedia.org/wiki/XML" class="external-link" target="_blank">XML</a>.
+Disons que vous voulez renvoyer une [réponse XML](https://en.wikipedia.org/wiki/XML).
-Vous pouvez mettre votre contenu XML dans une chaĂźne de caractĂšres, la placer dans une `Response`, et la retourner :
+Vous pouvez placer votre contenu XML dans une chaĂźne de caractĂšres, le mettre dans une `Response` et le renvoyer :
{* ../../docs_src/response_directly/tutorial002_py310.py hl[1,18] *}
+## Comprendre le fonctionnement d'un ModÚle de réponse { #how-a-response-model-works }
+
+Lorsque vous déclarez un [ModÚle de réponse - Type de retour](../tutorial/response-model.md) dans un chemin d'accÚs, **FastAPI** l'utilise pour sérialiser les données en JSON, en utilisant Pydantic.
+
+{* ../../docs_src/response_model/tutorial001_01_py310.py hl[16,21] *}
+
+Comme cela se passe cÎté Rust, la performance sera bien meilleure que si cela était fait avec le Python classique et la classe `JSONResponse`.
+
+Lorsque vous utilisez un `response_model` ou un type de retour, FastAPI n'utilise ni le `jsonable_encoder` pour convertir les données (ce qui serait plus lent) ni la classe `JSONResponse`.
+
+à la place, il prend les octets JSON générés avec Pydantic en utilisant le modÚle de réponse (ou le type de retour) et renvoie directement une `Response` avec le type de média approprié pour JSON (`application/json`).
+
## Notes { #notes }
Lorsque vous renvoyez une `Response` directement, ses données ne sont pas validées, converties (sérialisées), ni documentées automatiquement.
-Mais vous pouvez toujours les documenter comme décrit dans [Additional Responses in OpenAPI](additional-responses.md){.internal-link target=_blank}.
+Mais vous pouvez toujours les documenter comme décrit dans [Réponses supplémentaires dans OpenAPI](additional-responses.md).
-Vous pouvez voir dans les sections suivantes comment utiliser/déclarer ces `Response`s personnalisées tout en conservant la conversion automatique des données, la documentation, etc.
+Vous pouvez voir dans les sections suivantes comment utiliser/déclarer ces `Response` personnalisées tout en conservant la conversion automatique des données, la documentation, etc.
Vous pouvez Ă©galement ajouter des en-tĂȘtes lorsque vous renvoyez une `Response` directement.
-CrĂ©ez une rĂ©ponse comme dĂ©crit dans [Renvoyer une Response directement](response-directly.md){.internal-link target=_blank} et passez les en-tĂȘtes comme paramĂštre supplĂ©mentaire :
+CrĂ©ez une rĂ©ponse comme dĂ©crit dans [Renvoyer une Response directement](response-directly.md) et passez les en-tĂȘtes comme paramĂštre supplĂ©mentaire :
{* ../../docs_src/response_headers/tutorial001_py310.py hl[10:12] *}
## En-tĂȘtes personnalisĂ©s { #custom-headers }
-Gardez Ă l'esprit que des en-tĂȘtes propriĂ©taires personnalisĂ©s peuvent ĂȘtre ajoutĂ©s <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers" class="external-link" target="_blank">en utilisant le prĂ©fixe `X-`</a>.
+Gardez Ă l'esprit que des en-tĂȘtes propriĂ©taires personnalisĂ©s peuvent ĂȘtre ajoutĂ©s [en utilisant le prĂ©fixe `X-`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers).
-Mais si vous avez des en-tĂȘtes personnalisĂ©s que vous voulez qu'un client dans un navigateur puisse voir, vous devez les ajouter Ă vos configurations CORS (en savoir plus dans [CORS (Cross-Origin Resource Sharing)](../tutorial/cors.md){.internal-link target=_blank}), en utilisant le paramĂštre `expose_headers` documentĂ© dans <a href="https://www.starlette.dev/middleware/#corsmiddleware" class="external-link" target="_blank">la documentation CORS de Starlette</a>.
+Mais si vous avez des en-tĂȘtes personnalisĂ©s que vous voulez qu'un client dans un navigateur puisse voir, vous devez les ajouter Ă vos configurations CORS (en savoir plus dans [CORS (Cross-Origin Resource Sharing)](../tutorial/cors.md)), en utilisant le paramĂštre `expose_headers` documentĂ© dans [la documentation CORS de Starlette](https://www.starlette.dev/middleware/#corsmiddleware).
Utilisez une dépendance pour vérifier si le nom d'utilisateur et le mot de passe sont corrects.
-Pour cela, utilisez le module standard Python <a href="https://docs.python.org/3/library/secrets.html" class="external-link" target="_blank">`secrets`</a> pour vérifier le nom d'utilisateur et le mot de passe.
+Pour cela, utilisez le module standard Python [`secrets`](https://docs.python.org/3/library/secrets.html) pour vérifier le nom d'utilisateur et le mot de passe.
`secrets.compare_digest()` doit recevoir des `bytes` ou une `str` ne contenant que des caractĂšres ASCII (ceux de l'anglais), ce qui signifie qu'elle ne fonctionnerait pas avec des caractĂšres comme `ĂĄ`, comme dans `SebastiĂĄn`.
## Fonctionnalités supplémentaires { #additional-features }
-Il existe des fonctionnalités supplémentaires pour gérer la sécurité en plus de celles couvertes dans le [Tutoriel - Guide utilisateur : Sécurité](../../tutorial/security/index.md){.internal-link target=_blank}.
+Il existe des fonctionnalités supplémentaires pour gérer la sécurité en plus de celles couvertes dans le [Tutoriel - Guide utilisateur : Sécurité](../../tutorial/security/index.md).
/// tip | Astuce
-Les sections suivantes ne sont pas nécessairement « advanced ».
+Les sections suivantes **ne sont pas nécessairement « advanced »**.
Et il est possible que, pour votre cas dâutilisation, la solution se trouve dans lâune dâentre elles.
## Lire dâabord le tutoriel { #read-the-tutorial-first }
-Les sections suivantes partent du principe que vous avez déjà lu le [Tutoriel - Guide utilisateur : Sécurité](../../tutorial/security/index.md){.internal-link target=_blank} principal.
+Les sections suivantes partent du principe que vous avez déjà lu le [Tutoriel - Guide utilisateur : Sécurité](../../tutorial/security/index.md) principal.
Elles sâappuient toutes sur les mĂȘmes concepts, mais permettent des fonctionnalitĂ©s supplĂ©mentaires.
## Vue dâensemble { #global-view }
-Voyons dâabord rapidement les parties qui changent par rapport aux exemples du **Tutoriel - Guide utilisateur** pour [OAuth2 avec mot de passe (et hachage), Bearer avec jetons JWT](../../tutorial/security/oauth2-jwt.md){.internal-link target=_blank}. Cette fois, en utilisant des scopes OAuth2 :
+Voyons dâabord rapidement les parties qui changent par rapport aux exemples du **Tutoriel - Guide utilisateur** pour [OAuth2 avec mot de passe (et hachage), Bearer avec jetons JWT](../../tutorial/security/oauth2-jwt.md). Cette fois, en utilisant des scopes OAuth2 :
{* ../../docs_src/security/tutorial005_an_py310.py hl[5,9,13,47,65,106,108:116,122:126,130:136,141,157] *}
## `Security` dans les dépendances du décorateur `dependencies` { #security-in-decorator-dependencies }
-De la mĂȘme maniĂšre que vous pouvez dĂ©finir une `list` de `Depends` dans le paramĂštre `dependencies` du dĂ©corateur (comme expliquĂ© dans [DĂ©pendances dans les dĂ©corateurs de chemins dâaccĂšs](../../tutorial/dependencies/dependencies-in-path-operation-decorators.md){.internal-link target=_blank}), vous pouvez aussi utiliser `Security` avec des `scopes` Ă cet endroit.
+De la mĂȘme maniĂšre que vous pouvez dĂ©finir une `list` de `Depends` dans le paramĂštre `dependencies` du dĂ©corateur (comme expliquĂ© dans [DĂ©pendances dans les dĂ©corateurs de chemins dâaccĂšs](../../tutorial/dependencies/dependencies-in-path-operation-decorators.md)), vous pouvez aussi utiliser `Security` avec des `scopes` Ă cet endroit.
/// tip | Astuce
-Pour comprendre les variables d'environnement, vous pouvez lire [Variables d'environnement](../environment-variables.md){.internal-link target=_blank}.
+Pour comprendre les variables d'environnement, vous pouvez lire [Variables d'environnement](../environment-variables.md).
///
## Pydantic `Settings` { #pydantic-settings }
-Heureusement, Pydantic fournit un excellent utilitaire pour gérer ces paramÚtres provenant des variables d'environnement avec <a href="https://docs.pydantic.dev/latest/concepts/pydantic_settings/" class="external-link" target="_blank">Pydantic : gestion des paramÚtres</a>.
+Heureusement, Pydantic fournit un excellent utilitaire pour gérer ces paramÚtres provenant des variables d'environnement avec [Pydantic : gestion des paramÚtres](https://docs.pydantic.dev/latest/concepts/pydantic_settings/).
### Installer `pydantic-settings` { #install-pydantic-settings }
-D'abord, vous devez créer votre [environnement virtuel](../virtual-environments.md){.internal-link target=_blank}, l'activer, puis installer le paquet `pydantic-settings` :
+D'abord, vous devez créer votre [environnement virtuel](../virtual-environments.md), l'activer, puis installer le paquet `pydantic-settings` :
<div class="termy">
## ParamĂštres dans un autre module { #settings-in-another-module }
-Vous pouvez placer ces paramĂštres dans un autre module comme vous l'avez vu dans [Applications plus grandes - Plusieurs fichiers](../tutorial/bigger-applications.md){.internal-link target=_blank}.
+Vous pouvez placer ces paramĂštres dans un autre module comme vous l'avez vu dans [Applications plus grandes - Plusieurs fichiers](../tutorial/bigger-applications.md).
Par exemple, vous pourriez avoir un fichier `config.py` avec :
/// tip | Astuce
-Vous aurez Ă©galement besoin d'un fichier `__init__.py` comme vous l'avez vu dans [Applications plus grandes - Plusieurs fichiers](../tutorial/bigger-applications.md){.internal-link target=_blank}.
+Vous aurez Ă©galement besoin d'un fichier `__init__.py` comme vous l'avez vu dans [Applications plus grandes - Plusieurs fichiers](../tutorial/bigger-applications.md).
///
///
-Pydantic prend en charge la lecture depuis ce type de fichiers en utilisant une bibliothĂšque externe. Vous pouvez en lire davantage ici : <a href="https://docs.pydantic.dev/latest/concepts/pydantic_settings/#dotenv-env-support" class="external-link" target="_blank">Pydantic Settings : prise en charge de Dotenv (.env)</a>.
+Pydantic prend en charge la lecture depuis ce type de fichiers en utilisant une bibliothĂšque externe. Vous pouvez en lire davantage ici : [Pydantic Settings : prise en charge de Dotenv (.env)](https://docs.pydantic.dev/latest/concepts/pydantic_settings/#dotenv-env-support).
/// tip | Astuce
/// tip | Astuce
-L'attribut `model_config` est utilisé uniquement pour la configuration Pydantic. Vous pouvez en lire davantage ici : <a href="https://docs.pydantic.dev/latest/concepts/config/" class="external-link" target="_blank">Pydantic : Concepts : Configuration</a>.
+L'attribut `model_config` est utilisé uniquement pour la configuration Pydantic. Vous pouvez en lire davantage ici : [Pydantic : Concepts : Configuration](https://docs.pydantic.dev/latest/concepts/config/).
///
De cette façon, elle se comporte presque comme s'il s'agissait simplement d'une variable globale. Mais comme elle utilise une fonction de dépendance, nous pouvons alors la surcharger facilement pour les tests.
-`@lru_cache` fait partie de `functools` qui fait partie de la bibliothĂšque standard de Python, vous pouvez en lire davantage dans la <a href="https://docs.python.org/3/library/functools.html#functools.lru_cache" class="external-link" target="_blank">documentation Python pour `@lru_cache`</a>.
+`@lru_cache` fait partie de `functools` qui fait partie de la bibliothĂšque standard de Python, vous pouvez en lire davantage dans la [documentation Python pour `@lru_cache`](https://docs.python.org/3/library/functools.html#functools.lru_cache).
## RĂ©capitulatif { #recap }
### VĂ©rifier la documentation API automatique { #check-the-automatic-api-docs }
-Exécutez maintenant la commande `fastapi` avec votre fichier :
+Exécutez maintenant la commande `fastapi` :
<div class="termy">
```console
-$ fastapi dev main.py
+$ fastapi dev
<span style="color: green;">INFO</span>: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
```
</div>
-Puis ouvrez la documentation Ă <a href="http://127.0.0.1:8000/docs" class="external-link" target="_blank">http://127.0.0.1:8000/docs</a>.
+Et ouvrez la documentation Ă [http://127.0.0.1:8000/docs](http://127.0.0.1:8000/docs).
Vous verrez la documentation API automatique pour l'application principale, n'incluant que ses propres _chemins d'accĂšs_ :
<img src="/img/tutorial/sub-applications/image01.png">
-Ensuite, ouvrez la documentation de la sousâapplication Ă <a href="http://127.0.0.1:8000/subapi/docs" class="external-link" target="_blank">http://127.0.0.1:8000/subapi/docs</a>.
+Ensuite, ouvrez la documentation de la sousâapplication Ă [http://127.0.0.1:8000/subapi/docs](http://127.0.0.1:8000/subapi/docs).
Vous verrez la documentation API automatique pour la sousâapplication, n'incluant que ses propres _chemins d'accĂšs_, tous sous le prĂ©fixe de sousâchemin correct `/subapi` :
La sousâapplication peut Ă©galement avoir ses propres sousâapplications montĂ©es et tout fonctionnera correctement, car FastAPI gĂšre automatiquement tous ces `root_path`.
-Vous en apprendrez davantage sur `root_path` et sur la façon de l'utiliser explicitement dans la section [DerriÚre un proxy](behind-a-proxy.md){.internal-link target=_blank}.
+Vous en apprendrez davantage sur `root_path` et sur la façon de l'utiliser explicitement dans la section [DerriÚre un proxy](behind-a-proxy.md).
## Installer les dépendances { #install-dependencies }
-Vous devez créer un [environnement virtuel](../virtual-environments.md){.internal-link target=_blank}, l'activer, puis installer `jinja2` :
+Vous devez créer un [environnement virtuel](../virtual-environments.md), l'activer, puis installer `jinja2` :
<div class="termy">
## En savoir plus { #more-details }
-Pour plus de détails, y compris sur la façon de tester des templates, consultez <a href="https://www.starlette.dev/templates/" class="external-link" target="_blank">la documentation de Starlette sur les templates</a>.
+Pour plus de détails, y compris sur la façon de tester des templates, consultez [la documentation de Starlette sur les templates](https://www.starlette.dev/templates/).
/// note | Remarque
-Pour plus de détails, consultez la documentation de Starlette sur le <a href="https://www.starlette.dev/testclient/#testing-websocket-sessions" class="external-link" target="_blank">test des WebSockets</a>.
+Pour plus de détails, consultez la documentation de Starlette sur le [test des WebSockets](https://www.starlette.dev/testclient/#testing-websocket-sessions).
///
## DĂ©tails sur l'objet `Request` { #details-about-the-request-object }
-Comme **FastAPI** est en fait **Starlette** en dessous, avec une couche de plusieurs outils au-dessus, vous pouvez utiliser directement l'objet <a href="https://www.starlette.dev/requests/" class="external-link" target="_blank">`Request`</a> de Starlette lorsque vous en avez besoin.
+Comme **FastAPI** est en fait **Starlette** en dessous, avec une couche de plusieurs outils au-dessus, vous pouvez utiliser directement l'objet [`Request`](https://www.starlette.dev/requests/) de Starlette lorsque vous en avez besoin.
Cela signifie aussi que si vous récupérez des données directement à partir de l'objet `Request` (par exemple, lire le corps), elles ne seront pas validées, converties ni documentées (avec OpenAPI, pour l'interface utilisateur automatique de l'API) par FastAPI.
## Documentation de `Request` { #request-documentation }
-Vous pouvez lire plus de détails sur <a href="https://www.starlette.dev/requests/" class="external-link" target="_blank">l'objet `Request` sur le site de documentation officiel de Starlette</a>.
+Vous pouvez lire plus de détails sur [l'objet `Request` sur le site de documentation officiel de Starlette](https://www.starlette.dev/requests/).
/// note | DĂ©tails techniques
# WebSockets { #websockets }
-Vous pouvez utiliser <a href="https://developer.mozilla.org/en-US/docs/Web/API/WebSockets_API" class="external-link" target="_blank">API WebSockets</a> avec **FastAPI**.
+Vous pouvez utiliser [WebSockets](https://developer.mozilla.org/en-US/docs/Web/API/WebSockets_API) avec **FastAPI**.
## Installer `websockets` { #install-websockets }
-Vous devez créer un [environnement virtuel](../virtual-environments.md){.internal-link target=_blank}, l'activer, et installer `websockets` (une bibliothÚque Python qui facilite l'utilisation du protocole « WebSocket ») :
+Vous devez créer un [environnement virtuel](../virtual-environments.md), l'activer, et installer `websockets` (une bibliothÚque Python qui facilite l'utilisation du protocole « WebSocket ») :
<div class="termy">
## Essayer { #try-it }
-Si votre fichier s'appelle `main.py`, exécutez votre application avec :
+Mettez votre code dans un fichier `main.py` puis exécutez votre application :
<div class="termy">
```console
-$ fastapi dev main.py
+$ fastapi dev
<span style="color: green;">INFO</span>: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
```
</div>
-Ouvrez votre navigateur Ă l'adresse <a href="http://127.0.0.1:8000" class="external-link" target="_blank">http://127.0.0.1:8000</a>.
+Ouvrez votre navigateur Ă l'adresse [http://127.0.0.1:8000](http://127.0.0.1:8000).
Vous verrez une page simple comme :
Comme il s'agit d'un WebSocket, il n'est pas vraiment logique de lever une `HTTPException`, nous levons plutĂŽt une `WebSocketException`.
-Vous pouvez utiliser un code de fermeture parmi les <a href="https://tools.ietf.org/html/rfc6455#section-7.4.1" class="external-link" target="_blank">codes valides définis dans la spécification</a>.
+Vous pouvez utiliser un code de fermeture parmi les [codes valides définis dans la spécification](https://tools.ietf.org/html/rfc6455#section-7.4.1).
///
### Essayez les WebSockets avec des dépendances { #try-the-websockets-with-dependencies }
-Si votre fichier s'appelle `main.py`, exécutez votre application avec :
+Exécutez votre application :
<div class="termy">
```console
-$ fastapi dev main.py
+$ fastapi dev
<span style="color: green;">INFO</span>: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
```
</div>
-Ouvrez votre navigateur Ă l'adresse <a href="http://127.0.0.1:8000" class="external-link" target="_blank">http://127.0.0.1:8000</a>.
+Ouvrez votre navigateur Ă l'adresse [http://127.0.0.1:8000](http://127.0.0.1:8000).
Là , vous pouvez définir :
Mais gardez à l'esprit que, comme tout est géré en mémoire, dans une seule liste, cela ne fonctionnera que tant que le processus s'exécute et uniquement avec un seul processus.
-Si vous avez besoin de quelque chose de facile à intégrer avec FastAPI mais plus robuste, pris en charge par Redis, PostgreSQL ou autres, consultez <a href="https://github.com/encode/broadcaster" class="external-link" target="_blank">encode/broadcaster</a>.
+Si vous avez besoin de quelque chose de facile à intégrer avec FastAPI mais plus robuste, pris en charge par Redis, PostgreSQL ou autres, consultez [encode/broadcaster](https://github.com/encode/broadcaster).
///
Pour en savoir plus sur les options, consultez la documentation de Starlette concernant :
-* <a href="https://www.starlette.dev/websockets/" class="external-link" target="_blank">La classe `WebSocket`</a>.
-* <a href="https://www.starlette.dev/endpoints/#websocketendpoint" class="external-link" target="_blank">Gestion des WebSocket basée sur des classes</a>.
+* [La classe `WebSocket`](https://www.starlette.dev/websockets/).
+* [Gestion des WebSocket basée sur des classes](https://www.starlette.dev/endpoints/#websocketendpoint).
# Inclure WSGI - Flask, Django, autres { #including-wsgi-flask-django-others }
-Vous pouvez monter des applications WSGI comme vous l'avez vu avec [Sous-applications - Montages](sub-applications.md){.internal-link target=_blank}, [DerriĂšre un proxy](behind-a-proxy.md){.internal-link target=_blank}.
+Vous pouvez monter des applications WSGI comme vous l'avez vu avec [Sous-applications - Montages](sub-applications.md), [DerriĂšre un proxy](behind-a-proxy.md).
Pour cela, vous pouvez utiliser `WSGIMiddleware` et l'utiliser pour envelopper votre application WSGI, par exemple Flask, Django, etc.
Et le reste sera géré par **FastAPI**.
-Si vous l'exécutez et allez à <a href="http://localhost:8000/v1/" class="external-link" target="_blank">http://localhost:8000/v1/</a>, vous verrez la réponse de Flask :
+Si vous l'exécutez et allez à [http://localhost:8000/v1/](http://localhost:8000/v1/) vous verrez la réponse de Flask :
```txt
Hello, World from Flask!
```
-Et si vous allez à <a href="http://localhost:8000/v2" class="external-link" target="_blank">http://localhost:8000/v2</a>, vous verrez la réponse de FastAPI :
+Et si vous allez à [http://localhost:8000/v2](http://localhost:8000/v2) vous verrez la réponse de FastAPI :
```JSON
{
## Outils précédents { #previous-tools }
-### <a href="https://www.djangoproject.com/" class="external-link" target="_blank">Django</a> { #django }
+### [Django](https://www.djangoproject.com/) { #django }
C'est le framework Python le plus populaire et il bénéficie d'une grande confiance. Il est utilisé pour construire
des systĂšmes tel qu'Instagram.
Il a été créé pour générer le HTML en backend, pas pour créer des API consommées par un frontend moderne (comme React, Vue.js et Angular) ou par d'autres systÚmes (comme les appareils <abbr title="Internet of Things - Internet des objets">IoT</abbr>) communiquant avec lui.
-### <a href="https://www.django-rest-framework.org/" class="external-link" target="_blank">Django REST Framework</a> { #django-rest-framework }
+### [Django REST Framework](https://www.django-rest-framework.org/) { #django-rest-framework }
-Django REST framework a été conçu comme une boßte à outils flexible permettant de construire des API Web à partir de Django, afin d'améliorer ses capacités en matiÚre d'API.
+Django REST Framework a été conçu comme une boßte à outils flexible permettant de construire des API Web à partir de Django, afin d'améliorer ses capacités en matiÚre d'API.
Il est utilisé par de nombreuses entreprises, dont Mozilla, Red Hat et Eventbrite.
/// note | Remarque
-Django REST framework a été créé par Tom Christie. Le créateur de Starlette et Uvicorn, sur lesquels **FastAPI** est basé.
+Django REST Framework a été créé par Tom Christie. Le créateur de Starlette et Uvicorn, sur lesquels **FastAPI** est basé.
///
///
-### <a href="https://flask.palletsprojects.com" class="external-link" target="_blank">Flask</a> { #flask }
+### [Flask](https://flask.palletsprojects.com) { #flask }
Flask est un « microâframework », il ne comprend pas d'intĂ©grations de bases de donnĂ©es ni beaucoup de choses qui sont fournies par dĂ©faut dans Django.
///
-### <a href="https://requests.readthedocs.io" class="external-link" target="_blank">Requests</a> { #requests }
+### [Requests](https://requests.readthedocs.io) { #requests }
**FastAPI** n'est pas réellement une alternative à **Requests**. Leur cadre est trÚs différent.
///
-### <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 }
+### [Swagger](https://swagger.io/) / [OpenAPI](https://github.com/OAI/OpenAPI-Specification/) { #swagger-openapi }
La principale fonctionnalité que j'ai emprunté à Django REST Framework était la documentation automatique des API.
Intégrer des outils d'interface utilisateur basés sur des normes :
-* <a href="https://github.com/swagger-api/swagger-ui" class="external-link" target="_blank">Swagger UI</a>
-* <a href="https://github.com/Rebilly/ReDoc" class="external-link" target="_blank">ReDoc</a>
+* [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**).
découvert que le développement de beaucoup d'entre eux sont suspendus ou abandonnés, avec plusieurs problÚmes
permanents qui les rendent inadaptés.
-### <a href="https://marshmallow.readthedocs.io/en/stable/" class="external-link" target="_blank">Marshmallow</a> { #marshmallow }
+### [Marshmallow](https://marshmallow.readthedocs.io/en/stable/) { #marshmallow }
L'une des principales fonctionnalitĂ©s nĂ©cessaires aux systĂšmes API est la « <dfn title="aussi appelĂ© : marshalling, conversion">sĂ©rialisation</dfn> » des donnĂ©es, qui consiste Ă prendre les donnĂ©es du code (Python) et Ă
les convertir en quelque chose qui peut ĂȘtre envoyĂ© sur le rĂ©seau. Par exemple, convertir un objet contenant des
/// check | A inspirĂ© **FastAPI** Ă
-Utilisez du code pour définir des « schémas » qui fournissent automatiquement les types de données et la validation.
+Utiliser du code pour définir des « schémas » qui fournissent automatiquement les types de données et la validation.
///
-### <a href="https://webargs.readthedocs.io/en/latest/" class="external-link" target="_blank">Webargs</a> { #webargs }
+### [Webargs](https://webargs.readthedocs.io/en/latest/) { #webargs }
Une autre grande fonctionnalitĂ© requise par les API est lâ<dfn title="lecture et conversion en donnĂ©es Python">analyse</dfn> des donnĂ©es provenant des requĂȘtes entrantes.
///
-### <a href="https://apispec.readthedocs.io/en/stable/" class="external-link" target="_blank">APISpec</a> { #apispec }
+### [APISpec](https://apispec.readthedocs.io/en/stable/) { #apispec }
Marshmallow et Webargs fournissent la validation, l'analyse et la sérialisation en tant que plug-ins.
///
-### <a href="https://flask-apispec.readthedocs.io/en/latest/" class="external-link" target="_blank">Flask-apispec</a> { #flask-apispec }
+### [Flask-apispec](https://flask-apispec.readthedocs.io/en/latest/) { #flask-apispec }
C'est un plug-in pour Flask, qui relie Webargs, Marshmallow et APISpec.
Son utilisation a conduit à la création de plusieurs générateurs Flask full-stack. Ce sont les principales stacks que
j'ai (ainsi que plusieurs équipes externes) utilisées jusqu'à présent :
-* <a href="https://github.com/tiangolo/full-stack" class="external-link" target="_blank">https://github.com/tiangolo/full-stack</a>
-* <a href="https://github.com/tiangolo/full-stack-flask-couchbase" class="external-link" target="_blank">https://github.com/tiangolo/full-stack-flask-couchbase</a>
-* <a href="https://github.com/tiangolo/full-stack-flask-couchdb" class="external-link" target="_blank">https://github.com/tiangolo/full-stack-flask-couchdb</a>
+* [https://github.com/tiangolo/full-stack](https://github.com/tiangolo/full-stack)
+* [https://github.com/tiangolo/full-stack-flask-couchbase](https://github.com/tiangolo/full-stack-flask-couchbase)
+* [https://github.com/tiangolo/full-stack-flask-couchdb](https://github.com/tiangolo/full-stack-flask-couchdb)
-Ces mĂȘmes gĂ©nĂ©rateurs full-stack ont servi de base aux [GĂ©nĂ©rateurs de projets pour **FastAPI**](project-generation.md){.internal-link target=_blank}.
+Ces mĂȘmes gĂ©nĂ©rateurs full-stack ont servi de base aux [GĂ©nĂ©rateurs de projets pour **FastAPI**](project-generation.md).
/// info
///
-### <a href="https://nestjs.com/" class="external-link" target="_blank">NestJS</a> (et <a href="https://angular.io/" class="external-link" target="_blank">Angular</a>) { #nestjs-and-angular }
+### [NestJS](https://nestjs.com/) (et [Angular](https://angular.io/)) { #nestjs-and-angular }
Ce n'est mĂȘme pas du Python, NestJS est un framework JavaScript (TypeScript) NodeJS inspirĂ© d'Angular.
///
-### <a href="https://sanic.readthedocs.io/en/latest/" class="external-link" target="_blank">Sanic</a> { #sanic }
+### [Sanic](https://sanic.readthedocs.io/en/latest/) { #sanic }
C'Ă©tait l'un des premiers frameworks Python extrĂȘmement rapides basĂ©s sur `asyncio`. Il a Ă©tĂ© conçu pour ĂȘtre trĂšs similaire Ă Flask.
/// note | DĂ©tails techniques
-Il utilisait <a href="https://github.com/MagicStack/uvloop" class="external-link" target="_blank">`uvloop`</a> au lieu du systÚme par défaut de Python `asyncio`. C'est ce qui l'a rendu si rapide.
+Il utilisait [`uvloop`](https://github.com/MagicStack/uvloop) au lieu du systÚme par défaut de Python `asyncio`. C'est ce qui l'a rendu si rapide.
Il a clairement inspiré Uvicorn et Starlette, qui sont actuellement plus rapides que Sanic dans les benchmarks.
/// check | A inspirĂ© **FastAPI** Ă
-Trouvez un moyen d'avoir une performance folle.
+Trouver un moyen d'avoir une performance folle.
C'est pourquoi **FastAPI** est basé sur Starlette, car il s'agit du framework le plus rapide disponible (testé par des benchmarks tiers).
///
-### <a href="https://falconframework.org/" class="external-link" target="_blank">Falcon</a> { #falcon }
+### [Falcon](https://falconframework.org/) { #falcon }
Falcon est un autre framework Python haute performance, il est conçu pour ĂȘtre minimal, et est utilisĂ© comme fondation pour d'autres frameworks comme Hug.
Trouver des moyens d'obtenir de bonnes performances.
-Avec Hug (puisque Hug est basé sur Falcon), **FastAPI** a inspiré la déclaration d'un paramÚtre `response` dans les fonctions.
+Avec Hug (puisque Hug est basé sur Falcon), cela a inspiré **FastAPI** à déclarer un paramÚtre `response` dans les fonctions.
Bien que dans FastAPI, il est facultatif, et est utilisĂ© principalement pour dĂ©finir les en-tĂȘtes, les cookies, et les codes de statut alternatifs.
///
-### <a href="https://moltenframework.com/" class="external-link" target="_blank">Molten</a> { #molten }
+### [Molten](https://moltenframework.com/) { #molten }
J'ai découvert Molten lors des premiÚres étapes de développement de **FastAPI**. Et il a des idées assez similaires :
///
-### <a href="https://github.com/hugapi/hug" class="external-link" target="_blank">Hug</a> { #hug }
+### [Hug](https://github.com/hugapi/hug) { #hug }
Hug a Ă©tĂ© l'un des premiers frameworks Ă implĂ©menter la dĂ©claration des types de paramĂštres d'API en utilisant les annotations de type Python. C'Ă©tait une excellente idĂ©e qui a inspirĂ© d'autres outils Ă faire de mĂȘme.
/// info
-Hug a été créé par Timothy Crosley, le créateur de <a href="https://github.com/timothycrosley/isort" class="external-link" target="_blank">`isort`</a>, un excellent outil pour trier automatiquement les imports dans les fichiers Python.
+Hug a été créé par Timothy Crosley, le créateur de [`isort`](https://github.com/timothycrosley/isort), un excellent outil pour trier automatiquement les imports dans les fichiers Python.
///
///
-### <a href="https://github.com/encode/apistar" class="external-link" target="_blank">APIStar</a> (<= 0.5) { #apistar-0-5 }
+### [APIStar](https://github.com/encode/apistar) (<= 0.5) { #apistar-0-5 }
Juste avant de décider de développer **FastAPI**, j'ai trouvé le serveur **APIStar**. Il contenait presque tout ce
que je recherchais et avait un beau design.
## Utilisés par **FastAPI** { #used-by-fastapi }
-### <a href="https://docs.pydantic.dev/" class="external-link" target="_blank">Pydantic</a> { #pydantic }
+### [Pydantic](https://docs.pydantic.dev/) { #pydantic }
Pydantic est une bibliothÚque permettant de définir la validation, la sérialisation et la documentation des données (à l'aide de JSON Schema) en se basant sur les annotations de type Python.
///
-### <a href="https://www.starlette.dev/" class="external-link" target="_blank">Starlette</a> { #starlette }
+### [Starlette](https://www.starlette.dev/) { #starlette }
Starlette est un framework/toolkit léger <dfn title="La nouvelle norme pour créer des applications web Python asynchrones">ASGI</dfn>, qui est idéal pour construire des services asyncio performants.
///
-### <a href="https://www.uvicorn.dev/" class="external-link" target="_blank">Uvicorn</a> { #uvicorn }
+### [Uvicorn](https://www.uvicorn.dev/) { #uvicorn }
Uvicorn est un serveur ASGI rapide comme l'éclair, basé sur uvloop et httptools.
Vous pouvez Ă©galement utiliser l'option de ligne de commande `--workers` pour avoir un serveur multiâprocessus asynchrone.
-Pour plus de détails, consultez la section [Déploiement](deployment/index.md){.internal-link target=_blank}.
+Pour plus de détails, consultez la section [Déploiement](deployment/index.md).
///
## Benchmarks et vitesse { #benchmarks-and-speed }
-Pour comprendre, comparer et voir la différence entre Uvicorn, Starlette et FastAPI, consultez la section sur les [Benchmarks](benchmarks.md){.internal-link target=_blank}.
+Pour comprendre, comparer et voir la différence entre Uvicorn, Starlette et FastAPI, consultez la section sur les [Benchmarks](benchmarks.md).
---
-Si votre application n'a pas Ă communiquer avec une autre chose et Ă attendre sa rĂ©ponse, utilisez `async def`, mĂȘme si vous n'avez pas besoin d'utiliser `await` Ă l'intĂ©rieur.
+Si votre application (d'une certaine maniĂšre) n'a pas Ă communiquer avec une autre chose et Ă attendre sa rĂ©ponse, utilisez `async def`, mĂȘme si vous n'avez pas besoin d'utiliser `await` Ă l'intĂ©rieur.
---
-Si vous ne savez pas, utilisez seulement `def` comme vous le feriez habituellement.
+Si vous ne savez pas, utilisez seulement `def`.
---
/// info
-Illustrations proposĂ©es par <a href="https://www.instagram.com/ketrinadrawsalot" class="external-link" target="_blank">Ketrina Thompson</a>. đš
+Illustrations proposĂ©es par [Ketrina Thompson](https://www.instagram.com/ketrinadrawsalot). đš
///
/// info
-Illustrations proposĂ©es par <a href="https://www.instagram.com/ketrinadrawsalot" class="external-link" target="_blank">Ketrina Thompson</a>. đš
+Illustrations proposĂ©es par [Ketrina Thompson](https://www.instagram.com/ketrinadrawsalot). đš
///
Et c'est le mĂȘme niveau de performance que celui obtenu avec **FastAPI**.
-Et comme on peut avoir du parallĂ©lisme et de l'asynchronicitĂ© en mĂȘme temps, on obtient des performances plus hautes que la plupart des frameworks NodeJS testĂ©s et Ă©gales Ă celles du Go, qui est un langage compilĂ© plus proche du C <a href="https://www.techempower.com/benchmarks/#section=data-r17&hw=ph&test=query&l=zijmkf-1" class="external-link" target="_blank">(tout ça grĂące Ă Starlette)</a>.
+Et comme on peut avoir du parallĂ©lisme et de l'asynchronicitĂ© en mĂȘme temps, on obtient des performances plus hautes que la plupart des frameworks NodeJS testĂ©s et Ă©gales Ă celles du Go, qui est un langage compilĂ© plus proche du C [(tout ça grĂące Ă Starlette)](https://www.techempower.com/benchmarks/#section=data-r17&hw=ph&test=query&l=zijmkf-1).
### Est-ce que la concurrence est mieux que le parallélisme ? { #is-concurrency-better-than-parallelism }
Ăa, ajoutĂ© au fait que Python soit le langage le plus populaire pour la **Data Science**, le **Machine Learning** et surtout le **Deep Learning**, font de **FastAPI** un trĂšs bon choix pour les APIs et applications de **Data Science** / **Machine Learning**.
-Pour comprendre comment mettre en place ce parallélisme en production, allez lire la section [Déploiement](deployment/index.md){.internal-link target=_blank}.
+Pour comprendre comment mettre en place ce parallélisme en production, allez lire la section [Déploiement](deployment/index.md).
## `async` et `await` { #async-and-await }
### Ăcrire votre propre code async { #write-your-own-async-code }
-Starlette (et **FastAPI**) sâappuie sur <a href="https://anyio.readthedocs.io/en/stable/" class="external-link" target="_blank">AnyIO</a>, ce qui le rend compatible Ă la fois avec la bibliothĂšque standard <a href="https://docs.python.org/3/library/asyncio-task.html" class="external-link" target="_blank">asyncio</a> de Python et avec <a href="https://trio.readthedocs.io/en/stable/" class="external-link" target="_blank">Trio</a>.
+Starlette (et **FastAPI**) sâappuie sur [AnyIO](https://anyio.readthedocs.io/en/stable/), ce qui le rend compatible Ă la fois avec la bibliothĂšque standard [asyncio](https://docs.python.org/3/library/asyncio-task.html) de Python et avec [Trio](https://trio.readthedocs.io/en/stable/).
-En particulier, vous pouvez utiliser directement <a href="https://anyio.readthedocs.io/en/stable/" class="external-link" target="_blank">AnyIO</a> pour vos cas dâusage de concurrence avancĂ©s qui nĂ©cessitent des schĂ©mas plus Ă©laborĂ©s dans votre propre code.
+En particulier, vous pouvez utiliser directement [AnyIO](https://anyio.readthedocs.io/en/stable/) pour vos cas dâusage de concurrence avancĂ©s qui nĂ©cessitent des schĂ©mas plus Ă©laborĂ©s dans votre propre code.
-Et mĂȘme si vous nâutilisiez pas FastAPI, vous pourriez aussi Ă©crire vos propres applications async avec <a href="https://anyio.readthedocs.io/en/stable/" class="external-link" target="_blank">AnyIO</a> pour une grande compatibilitĂ© et pour bĂ©nĂ©ficier de ses avantages (par ex. la « structured concurrency »).
+Et mĂȘme si vous nâutilisiez pas FastAPI, vous pourriez aussi Ă©crire vos propres applications async avec [AnyIO](https://anyio.readthedocs.io/en/stable/) pour une grande compatibilitĂ© et pour bĂ©nĂ©ficier de ses avantages (par ex. la « structured concurrency »).
-Jâai crĂ©Ă© une autre bibliothĂšque au-dessus dâAnyIO, comme une fine surcouche, pour amĂ©liorer un peu les annotations de type et obtenir une meilleure **autocomplĂ©tion**, des **erreurs en ligne**, etc. Elle propose Ă©galement une introduction et un tutoriel accessibles pour vous aider Ă **comprendre** et Ă©crire **votre propre code async** : <a href="https://asyncer.tiangolo.com/" class="external-link" target="_blank">Asyncer</a>. Elle sera particuliĂšrement utile si vous devez **combiner du code async avec du code classique** (bloquant/synchrone).
+Jâai crĂ©Ă© une autre bibliothĂšque au-dessus dâAnyIO, comme une fine surcouche, pour amĂ©liorer un peu les annotations de type et obtenir une meilleure **autocomplĂ©tion**, des **erreurs en ligne**, etc. Elle propose Ă©galement une introduction et un tutoriel accessibles pour vous aider Ă **comprendre** et Ă©crire **votre propre code async** : [Asyncer](https://asyncer.tiangolo.com/). Elle sera particuliĂšrement utile si vous devez **combiner du code async avec du code classique** (bloquant/synchrone).
### Autres formes de code asynchrone { #other-forms-of-asynchronous-code }
Mais avant ça, gérer du code asynchrone était bien plus complexe et difficile.
-Dans les versions précédentes de Python, vous auriez utilisé des threads ou <a href="https://www.gevent.org/" class="external-link" target="_blank">Gevent</a>. Mais le code aurait été bien plus difficile à comprendre, débugger, et concevoir.
+Dans les versions précédentes de Python, vous auriez utilisé des threads ou [Gevent](https://www.gevent.org/). Mais le code aurait été bien plus difficile à comprendre, débugger, et concevoir.
Dans les versions précédentes de JavaScript cÎté navigateur / NodeJS, vous auriez utilisé des « callbacks ». Menant potentiellement à ce que l'on appelle le « callback hell ».
Si vous venez d'un autre framework asynchrone qui ne fonctionne pas comme de la façon dĂ©crite ci-dessus et que vous ĂȘtes habituĂ© Ă dĂ©finir des *fonctions de chemin d'accĂšs* basiques et purement calculatoires avec un simple `def` pour un faible gain de performance (environ 100 nanosecondes), veuillez noter que dans **FastAPI**, l'effet serait plutĂŽt contraire. Dans ces cas-lĂ , il vaut mieux utiliser `async def` Ă moins que votre *fonction de chemin d'accĂšs* utilise du code qui effectue des opĂ©rations <abbr title="Input/Output - EntrĂ©es/Sorties: lecture ou Ă©criture sur le disque, communications rĂ©seau.">I/O</abbr> bloquantes.
-Au final, dans les deux situations, il est fort probable que **FastAPI** soit tout de mĂȘme [plus rapide](index.md#performance){.internal-link target=_blank} que (ou au moins de vitesse Ă©gale Ă ) votre framework prĂ©cĂ©dent.
+Au final, dans les deux situations, il est fort probable que **FastAPI** soit tout de mĂȘme [plus rapide](index.md#performance) que (ou au moins de vitesse Ă©gale Ă ) votre framework prĂ©cĂ©dent.
### DĂ©pendances { #dependencies }
-La mĂȘme chose s'applique aux [dĂ©pendances](tutorial/dependencies/index.md){.internal-link target=_blank}. Si une dĂ©pendance est dĂ©finie avec `def` plutĂŽt que `async def`, elle est exĂ©cutĂ©e dans la threadpool externe.
+La mĂȘme chose s'applique aux [dĂ©pendances](tutorial/dependencies/index.md). Si une dĂ©pendance est dĂ©finie avec `def` plutĂŽt que `async def`, elle est exĂ©cutĂ©e dans la threadpool externe.
### Sous-dépendances { #sub-dependencies }
-Vous pouvez avoir de multiples dĂ©pendances et [sous-dĂ©pendances](tutorial/dependencies/sub-dependencies.md){.internal-link target=_blank} dĂ©pendant les unes des autres (en tant que paramĂštres de la dĂ©finition de la *fonction de chemin d'accĂšs*), certaines crĂ©Ă©es avec `async def` et d'autres avec `def`. Cela fonctionnerait aussi, et celles dĂ©finies avec un simple `def` seraient exĂ©cutĂ©es sur un thread externe (venant de la threadpool) plutĂŽt que d'ĂȘtre « attendues ».
+Vous pouvez avoir de multiples dĂ©pendances et [sous-dĂ©pendances](tutorial/dependencies/sub-dependencies.md) dĂ©pendant les unes des autres (en tant que paramĂštres de la dĂ©finition de la *fonction de chemin d'accĂšs*), certaines crĂ©Ă©es avec `async def` et d'autres avec `def`. Cela fonctionnerait aussi, et celles dĂ©finies avec un simple `def` seraient exĂ©cutĂ©es sur un thread externe (venant de la threadpool) plutĂŽt que d'ĂȘtre « attendues ».
### Autres fonctions utilitaires { #other-utility-functions }
# Tests de performance { #benchmarks }
-Les benchmarks indĂ©pendants de TechEmpower montrent que les applications **FastAPI** sâexĂ©cutant avec Uvicorn sont <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">parmi les frameworks Python les plus rapides disponibles</a>, seulement en dessous de Starlette et Uvicorn euxâmĂȘmes (tous deux utilisĂ©s en interne par FastAPI).
+Les benchmarks indĂ©pendants de TechEmpower montrent que les applications **FastAPI** sâexĂ©cutant avec Uvicorn sont [parmi les frameworks Python les plus rapides disponibles](https://www.techempower.com/benchmarks/#section=test&runid=7464e520-0dc2-473d-bd34-dbdfd7e85911&hw=ph&test=query&l=zijzen-7), seulement en dessous de Starlette et Uvicorn euxâmĂȘmes (tous deux utilisĂ©s en interne par FastAPI).
Mais en prĂȘtant attention aux tests de performance et aux comparaisons, vous devez tenir compte de ce qui suit.
## FastAPI Cloud { #fastapi-cloud }
-**<a href="https://fastapicloud.com" class="external-link" target="_blank">FastAPI Cloud</a>** est crĂ©Ă©e par le mĂȘme auteur et l'Ă©quipe Ă l'origine de **FastAPI**.
+**[FastAPI Cloud](https://fastapicloud.com)** est crĂ©Ă©e par le mĂȘme auteur et l'Ă©quipe Ă l'origine de **FastAPI**.
Elle simplifie le processus de **création**, de **déploiement** et **d'accÚs** à une API avec un effort minimal.
## Fournisseurs cloud - Sponsors { #cloud-providers-sponsors }
-D'autres fournisseurs cloud âš [**parrainent FastAPI**](../help-fastapi.md#sponsor-the-author){.internal-link target=_blank} âš Ă©galement. đ
+D'autres fournisseurs cloud âš [**parrainent FastAPI**](../help-fastapi.md#sponsor-the-author) âš Ă©galement. đ
Vous pouvez Ă©galement envisager ces fournisseurs pour suivre leurs guides et essayer leurs services :
-* <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>
+* [Render](https://docs.render.com/deploy-fastapi?utm_source=deploydoc&utm_medium=referral&utm_campaign=fastapi)
+* [Railway](https://docs.railway.com/guides/fastapi?utm_medium=integration&utm_source=docs&utm_campaign=fastapi)
## Sécurité - HTTPS { #security-https }
-Dans le [chapitre précédent à propos de HTTPS](https.md){.internal-link target=_blank}, nous avons vu comment HTTPS fournit le chiffrement pour votre API.
+Dans le [chapitre précédent à propos de HTTPS](https.md), nous avons vu comment HTTPS fournit le chiffrement pour votre API.
Nous avons Ă©galement vu que HTTPS est normalement fourni par un composant **externe** Ă votre serveur d'application, un **TLS Termination Proxy**.
### Processus workers et ports { #worker-processes-and-ports }
-Rappelezâvous, d'aprĂšs les documents [Ă propos de HTTPS](https.md){.internal-link target=_blank}, qu'un seul processus peut Ă©couter une combinaison de port et d'adresse IP sur un serveur ?
+Rappelezâvous, d'aprĂšs les documents [Ă propos de HTTPS](https.md), qu'un seul processus peut Ă©couter une combinaison de port et d'adresse IP sur un serveur ?
C'est toujours vrai.
Ne vous inquiétez pas si certains de ces éléments concernant les **conteneurs**, Docker ou Kubernetes ne sont pas encore trÚs clairs.
-Je vous en dirai plus sur les images de conteneurs, Docker, Kubernetes, etc. dans un chapitre Ă venir : [FastAPI dans des conteneurs - Docker](docker.md){.internal-link target=_blank}.
+Je vous en dirai plus sur les images de conteneurs, Docker, Kubernetes, etc. dans un chapitre Ă venir : [FastAPI dans des conteneurs - Docker](docker.md).
///
/// tip | Astuce
-Je vous donnerai des exemples plus concrets pour faire cela avec des conteneurs dans un chapitre Ă venir : [FastAPI dans des conteneurs - Docker](docker.md){.internal-link target=_blank}.
+Je vous donnerai des exemples plus concrets pour faire cela avec des conteneurs dans un chapitre Ă venir : [FastAPI dans des conteneurs - Docker](docker.md).
///
# FastAPI dans des conteneurs - Docker { #fastapi-in-containers-docker }
-Lors du déploiement d'applications FastAPI, une approche courante consiste à construire une **image de conteneur Linux**. C'est généralement fait avec <a href="https://www.docker.com/" class="external-link" target="_blank">**Docker**</a>. Vous pouvez ensuite déployer cette image de conteneur de plusieurs façons possibles.
+Lors du déploiement d'applications FastAPI, une approche courante consiste à construire une **image de conteneur Linux**. C'est généralement fait avec [**Docker**](https://www.docker.com/). Vous pouvez ensuite déployer cette image de conteneur de plusieurs façons possibles.
L'utilisation de conteneurs Linux présente plusieurs avantages, notamment la **sécurité**, la **réplicabilité**, la **simplicité**, entre autres.
Docker a été l'un des principaux outils pour créer et gérer des **images de conteneur** et des **conteneurs**.
-Et il existe un <a href="https://hub.docker.com/" class="external-link" target="_blank">Docker Hub</a> public avec des **images de conteneur officielles** pré-construites pour de nombreux outils, environnements, bases de données et applications.
+Et il existe un [Docker Hub](https://hub.docker.com/) public avec des **images de conteneur officielles** pré-construites pour de nombreux outils, environnements, bases de données et applications.
-Par exemple, il existe une <a href="https://hub.docker.com/_/python" class="external-link" target="_blank">image Python officielle</a>.
+Par exemple, il existe une [image Python officielle](https://hub.docker.com/_/python).
Et il existe beaucoup d'autres images pour différentes choses comme des bases de données, par exemple :
-* <a href="https://hub.docker.com/_/postgres" class="external-link" target="_blank">PostgreSQL</a>
-* <a href="https://hub.docker.com/_/mysql" class="external-link" target="_blank">MySQL</a>
-* <a href="https://hub.docker.com/_/mongo" class="external-link" target="_blank">MongoDB</a>
-* <a href="https://hub.docker.com/_/redis" class="external-link" target="_blank">Redis</a>, etc.
+* [PostgreSQL](https://hub.docker.com/_/postgres)
+* [MySQL](https://hub.docker.com/_/mysql)
+* [MongoDB](https://hub.docker.com/_/mongo)
+* [Redis](https://hub.docker.com/_/redis), etc.
En utilisant une image de conteneur pré-construite, il est trÚs facile de **combiner** et d'utiliser différents outils. Par exemple, pour essayer une nouvelle base de données. Dans la plupart des cas, vous pouvez utiliser les **images officielles** et simplement les configurer avec des variables d'environnement.
La maniĂšre la plus courante consiste Ă avoir un fichier `requirements.txt` avec les noms des paquets et leurs versions, un par ligne.
-Vous utiliserez bien sĂ»r les mĂȘmes idĂ©es que vous avez lues dans [Ă propos des versions de FastAPI](versions.md){.internal-link target=_blank} pour dĂ©finir les plages de versions.
+Vous utiliserez bien sĂ»r les mĂȘmes idĂ©es que vous avez lues dans [Ă propos des versions de FastAPI](versions.md) pour dĂ©finir les plages de versions.
Par exemple, votre `requirements.txt` pourrait ressembler Ă :
#### Utiliser `CMD` - Forme Exec { #use-cmd-exec-form }
-L'instruction Docker <a href="https://docs.docker.com/reference/dockerfile/#cmd" class="external-link" target="_blank">`CMD`</a> peut ĂȘtre Ă©crite sous deux formes :
+L'instruction Docker [`CMD`](https://docs.docker.com/reference/dockerfile/#cmd) peut ĂȘtre Ă©crite sous deux formes :
â
Forme **Exec** :
CMD fastapi run app/main.py --port 80
```
-Assurez-vous d'utiliser toujours la forme **exec** pour garantir que FastAPI peut s'arrĂȘter proprement et que les [Ă©vĂ©nements de cycle de vie](../advanced/events.md){.internal-link target=_blank} sont dĂ©clenchĂ©s.
+Assurez-vous d'utiliser toujours la forme **exec** pour garantir que FastAPI peut s'arrĂȘter proprement et que les [Ă©vĂ©nements de cycle de vie](../advanced/events.md) sont dĂ©clenchĂ©s.
-Vous pouvez en lire davantage dans la <a href="https://docs.docker.com/reference/dockerfile/#shell-and-exec-form" class="external-link" target="_blank">documentation Docker sur les formes shell et exec</a>.
+Vous pouvez en lire davantage dans la [documentation Docker sur les formes shell et exec](https://docs.docker.com/reference/dockerfile/#shell-and-exec-form).
-Cela peut ĂȘtre trĂšs visible lors de l'utilisation de `docker compose`. Voir cette section de la FAQ Docker Compose pour plus de dĂ©tails techniques : <a href="https://docs.docker.com/compose/faq/#why-do-my-services-take-10-seconds-to-recreate-or-stop" class="external-link" target="_blank">Pourquoi mes services mettent-ils 10 secondes Ă se recrĂ©er ou Ă s'arrĂȘter ?</a>.
+Cela peut ĂȘtre trĂšs visible lors de l'utilisation de `docker compose`. Voir cette section de la FAQ Docker Compose pour plus de dĂ©tails techniques : [Pourquoi mes services mettent-ils 10 secondes Ă se recrĂ©er ou Ă s'arrĂȘter ?](https://docs.docker.com/compose/faq/#why-do-my-services-take-10-seconds-to-recreate-or-stop).
#### Structure du répertoire { #directory-structure }
## VĂ©rifier { #check-it }
-Vous devriez pouvoir le vérifier via l'URL de votre conteneur Docker, par exemple : <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> ou <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> (ou équivalent, en utilisant votre hÎte Docker).
+Vous devriez pouvoir le vérifier via l'URL de votre conteneur Docker, par exemple : [http://192.168.99.100/items/5?q=somequery](http://192.168.99.100/items/5?q=somequery) ou [http://127.0.0.1/items/5?q=somequery](http://127.0.0.1/items/5?q=somequery) (ou équivalent, en utilisant votre hÎte Docker).
Vous verrez quelque chose comme :
## Documentation interactive de l'API { #interactive-api-docs }
-Vous pouvez maintenant aller sur <a href="http://192.168.99.100/docs" class="external-link" target="_blank">http://192.168.99.100/docs</a> ou <a href="http://127.0.0.1/docs" class="external-link" target="_blank">http://127.0.0.1/docs</a> (ou Ă©quivalent, en utilisant votre hĂŽte Docker).
+Vous pouvez maintenant aller sur [http://192.168.99.100/docs](http://192.168.99.100/docs) ou [http://127.0.0.1/docs](http://127.0.0.1/docs) (ou Ă©quivalent, en utilisant votre hĂŽte Docker).
-Vous verrez la documentation interactive automatique de l'API (fournie par <a href="https://github.com/swagger-api/swagger-ui" class="external-link" target="_blank">Swagger UI</a>) :
+Vous verrez la documentation interactive automatique de l'API (fournie par [Swagger UI](https://github.com/swagger-api/swagger-ui)) :
## Documentation alternative de l'API { #alternative-api-docs }
-Et vous pouvez aussi aller sur <a href="http://192.168.99.100/redoc" class="external-link" target="_blank">http://192.168.99.100/redoc</a> ou <a href="http://127.0.0.1/redoc" class="external-link" target="_blank">http://127.0.0.1/redoc</a> (ou Ă©quivalent, en utilisant votre hĂŽte Docker).
+Et vous pouvez aussi aller sur [http://192.168.99.100/redoc](http://192.168.99.100/redoc) ou [http://127.0.0.1/redoc](http://127.0.0.1/redoc) (ou Ă©quivalent, en utilisant votre hĂŽte Docker).
-Vous verrez la documentation automatique alternative (fournie par <a href="https://github.com/Rebilly/ReDoc" class="external-link" target="_blank">ReDoc</a>) :
+Vous verrez la documentation automatique alternative (fournie par [ReDoc](https://github.com/Rebilly/ReDoc)) :
## Concepts de déploiement { #deployment-concepts }
-Parlons Ă nouveau de certains des mĂȘmes [Concepts de dĂ©ploiement](concepts.md){.internal-link target=_blank} en termes de conteneurs.
+Parlons Ă nouveau de certains des mĂȘmes [Concepts de dĂ©ploiement](concepts.md) en termes de conteneurs.
Les conteneurs sont principalement un outil pour simplifier le processus de **construction et de déploiement** d'une application, mais ils n'imposent pas une approche particuliÚre pour gérer ces **concepts de déploiement**, et il existe plusieurs stratégies possibles.
Si l'on se concentre uniquement sur l'**image de conteneur** pour une application FastAPI (et plus tard sur le **conteneur** en cours d'exécution), HTTPS serait normalement géré **à l'extérieur** par un autre outil.
-Cela pourrait ĂȘtre un autre conteneur, par exemple avec <a href="https://traefik.io/" class="external-link" target="_blank">Traefik</a>, gĂ©rant **HTTPS** et l'acquisition **automatique** des **certificats**.
+Cela pourrait ĂȘtre un autre conteneur, par exemple avec [Traefik](https://traefik.io/), gĂ©rant **HTTPS** et l'acquisition **automatique** des **certificats**.
/// tip | Astuce
/// info
-Si vous utilisez Kubernetes, ce sera probablement un <a href="https://kubernetes.io/docs/concepts/workloads/pods/init-containers/" class="external-link" target="_blank">Init Container</a>.
+Si vous utilisez Kubernetes, ce sera probablement un [Init Container](https://kubernetes.io/docs/concepts/workloads/pods/init-containers/).
///
### Image Docker de base { #base-docker-image }
-Il existait une image Docker officielle FastAPI : <a href="https://github.com/tiangolo/uvicorn-gunicorn-fastapi-docker" class="external-link" target="_blank">tiangolo/uvicorn-gunicorn-fastapi</a>. Mais elle est dĂ©sormais dĂ©prĂ©ciĂ©e. âïž
+Il existait une image Docker officielle FastAPI : [tiangolo/uvicorn-gunicorn-fastapi](https://github.com/tiangolo/uvicorn-gunicorn-fastapi-docker). Mais elle est dĂ©sormais dĂ©prĂ©ciĂ©e. âïž
Vous ne devriez probablement **pas** utiliser cette image Docker de base (ni aucune autre similaire).
## Image Docker avec `uv` { #docker-image-with-uv }
-Si vous utilisez <a href="https://github.com/astral-sh/uv" class="external-link" target="_blank">uv</a> pour installer et gérer votre projet, vous pouvez suivre leur <a href="https://docs.astral.sh/uv/guides/integration/docker/" class="external-link" target="_blank">guide Docker pour uv</a>.
+Si vous utilisez [uv](https://github.com/astral-sh/uv) pour installer et gérer votre projet, vous pouvez suivre leur [guide Docker pour uv](https://docs.astral.sh/uv/guides/integration/docker/).
## RĂ©capitulatif { #recap }
# FastAPI Cloud { #fastapi-cloud }
-Vous pouvez dĂ©ployer votre application FastAPI sur <a href="https://fastapicloud.com" class="external-link" target="_blank">FastAPI Cloud</a> avec une **seule commande**, allez vous inscrire sur la liste dâattente si ce nâest pas dĂ©jĂ fait. đ
+Vous pouvez dĂ©ployer votre application FastAPI sur [FastAPI Cloud](https://fastapicloud.com) avec une **seule commande**, allez vous inscrire sur la liste dâattente si ce nâest pas dĂ©jĂ fait. đ
## Se connecter { #login }
## Ă propos de FastAPI Cloud { #about-fastapi-cloud }
-**<a href="https://fastapicloud.com" class="external-link" target="_blank">FastAPI Cloud</a>** est dĂ©veloppĂ© par le mĂȘme auteur et la mĂȘme Ă©quipe Ă lâorigine de **FastAPI**.
+**[FastAPI Cloud](https://fastapicloud.com)** est dĂ©veloppĂ© par le mĂȘme auteur et la mĂȘme Ă©quipe Ă lâorigine de **FastAPI**.
Cela simplifie le processus de **crĂ©ation**, de **dĂ©ploiement** et **dâaccĂšs** Ă une API avec un effort minimal.
///
-Pour apprendre les bases du HTTPS, du point de vue d'un utilisateur, consultez <a href="https://howhttps.works/" class="external-link" target="_blank">https://howhttps.works/</a>.
+Pour apprendre les bases du HTTPS, du point de vue d'un utilisateur, consultez [https://howhttps.works/](https://howhttps.works/).
Maintenant, du point de vue d'un dĂ©veloppeur, voici plusieurs choses Ă avoir en tĂȘte en pensant au HTTPS :
* **Par défaut**, cela signifie que vous ne pouvez avoir qu'**un seul certificat HTTPS par adresse IP**.
* Quelle que soit la taille de votre serveur ou la petitesse de chacune des applications qu'il contient.
* Il existe cependant une **solution** Ă ce problĂšme.
-* Il existe une **extension** du protocole **TLS** (celui qui gÚre le cryptage au niveau TCP, avant HTTP) appelée **<a href="https://en.wikipedia.org/wiki/Server_Name_Indication" class="external-link" target="_blank"><abbr title="Server Name Indication - Indication du nom du serveur">SNI</abbr></a>**.
+* Il existe une **extension** du protocole **TLS** (celui qui gÚre le cryptage au niveau TCP, avant HTTP) appelée **[<abbr title="Server Name Indication - Indication du nom du serveur">SNI</abbr>](https://en.wikipedia.org/wiki/Server_Name_Indication)**.
* Cette extension SNI permet Ă un seul serveur (avec une **seule adresse IP**) d'avoir **plusieurs certificats HTTPS** et de servir **plusieurs domaines/applications HTTPS**.
* Pour que cela fonctionne, un **seul** composant (programme) fonctionnant sur le serveur, Ă©coutant sur l'**adresse IP publique**, doit avoir **tous les certificats HTTPS** du serveur.
* **AprÚs** l'établissement d'une connexion sécurisée, le protocole de communication est **toujours HTTP**.
* Le contenu est **cryptĂ©**, mĂȘme s'il est envoyĂ© avec le **protocole HTTP**.
-Il est courant d'avoir **un seul programme/serveur HTTP** fonctionnant sur le serveur (la machine, l'hĂŽte, etc.) et **gĂ©rant toutes les parties HTTPS** : recevoir les **requĂȘtes HTTPS chiffrĂ©es**, envoyer les **requĂȘtes HTTP dĂ©chiffrĂ©es** Ă l'application HTTP rĂ©elle fonctionnant sur le mĂȘme serveur (l'application **FastAPI**, dans ce cas), prendre la **rĂ©ponse HTTP** de l'application, la **chiffrer** en utilisant le **certificat HTTPS** appropriĂ© et la renvoyer au client en utilisant **HTTPS**. Ce serveur est souvent appelĂ© un **<a href="https://en.wikipedia.org/wiki/TLS_termination_proxy" class="external-link" target="_blank">Proxy de terminaison TLS</a>**.
+Il est courant d'avoir **un seul programme/serveur HTTP** fonctionnant sur le serveur (la machine, l'hĂŽte, etc.) et **gĂ©rant toutes les parties HTTPS** : recevoir les **requĂȘtes HTTPS chiffrĂ©es**, envoyer les **requĂȘtes HTTP dĂ©chiffrĂ©es** Ă l'application HTTP rĂ©elle fonctionnant sur le mĂȘme serveur (l'application **FastAPI**, dans ce cas), prendre la **rĂ©ponse HTTP** de l'application, la **chiffrer** en utilisant le **certificat HTTPS** appropriĂ© et la renvoyer au client en utilisant **HTTPS**. Ce serveur est souvent appelĂ© un **[Proxy de terminaison TLS](https://en.wikipedia.org/wiki/TLS_termination_proxy)**.
Parmi les options que vous pourriez utiliser comme Proxy de terminaison TLSÂ :
Le processus d'acquisition de l'un de ces certificats était auparavant lourd, nécessitait pas mal de paperasses et les certificats étaient assez chers.
-Mais ensuite, **<a href="https://letsencrypt.org/" class="external-link" target="_blank">Let's Encrypt</a>** a été créé.
+Mais ensuite, **[Let's Encrypt](https://letsencrypt.org/)** a été créé.
Il s'agit d'un projet de la Fondation Linux. Il fournit **des certificats HTTPS gratuitement**, de maniÚre automatisée. Ces certificats utilisent toutes les sécurités cryptographiques standard et ont une durée de vie courte (environ 3 mois), de sorte que la **sécurité est en fait meilleure** en raison de leur durée de vie réduite.
Les en-tĂȘtes du proxy sont :
-* <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/X-Forwarded-For" class="external-link" target="_blank">X-Forwarded-For</a>
-* <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/X-Forwarded-Proto" class="external-link" target="_blank">X-Forwarded-Proto</a>
-* <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/X-Forwarded-Host" class="external-link" target="_blank">X-Forwarded-Host</a>
+* [X-Forwarded-For](https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/X-Forwarded-For)
+* [X-Forwarded-Proto](https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/X-Forwarded-Proto)
+* [X-Forwarded-Host](https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/X-Forwarded-Host)
///
/// tip | Astuce
-Vous pouvez en savoir plus dans la documentation [DerriĂšre un proxy - Activer les en-tĂȘtes transmis par le proxy](../advanced/behind-a-proxy.md#enable-proxy-forwarded-headers){.internal-link target=_blank}
+Vous pouvez en savoir plus dans la documentation [DerriĂšre un proxy - Activer les en-tĂȘtes transmis par le proxy](../advanced/behind-a-proxy.md#enable-proxy-forwarded-headers)
///
Vous pouvez **dĂ©ployer un serveur** vous-mĂȘme en utilisant une combinaison d'outils, vous pouvez utiliser un **service
cloud** qui fait une partie du travail pour vous, ou encore d'autres options possibles.
-Par exemple, nous, l'Ă©quipe derriĂšre FastAPI, avons crĂ©Ă© <a href="https://fastapicloud.com" class="external-link" target="_blank">**FastAPI Cloud**</a>, pour rendre le dĂ©ploiement d'applications FastAPI dans le cloud aussi fluide que possible, avec la mĂȘme expĂ©rience dĂ©veloppeur que lorsque vous travaillez avec FastAPI.
+Par exemple, nous, l'Ă©quipe derriĂšre FastAPI, avons crĂ©Ă© [**FastAPI Cloud**](https://fastapicloud.com), pour rendre le dĂ©ploiement d'applications FastAPI dans le cloud aussi fluide que possible, avec la mĂȘme expĂ©rience dĂ©veloppeur que lorsque vous travaillez avec FastAPI.
Je vais vous montrer certains des principaux concepts que vous devriez probablement avoir à l'esprit lors du déploiement
d'une application **FastAPI** (bien que la plupart de ces concepts s'appliquent Ă tout autre type d'application web).
Il existe plusieurs alternatives, notamment :
-* <a href="https://www.uvicorn.dev/" class="external-link" target="_blank">Uvicorn</a>Â : un serveur ASGI haute performance.
-* <a href="https://hypercorn.readthedocs.io/" class="external-link" target="_blank">Hypercorn</a> : un serveur ASGI compatible avec HTTP/2 et Trio entre autres fonctionnalités.
-* <a href="https://github.com/django/daphne" class="external-link" target="_blank">Daphne</a> : le serveur ASGI conçu pour Django Channels.
-* <a href="https://github.com/emmett-framework/granian" class="external-link" target="_blank">Granian</a>Â : un serveur HTTP Rust pour les applications Python.
-* <a href="https://unit.nginx.org/howto/fastapi/" class="external-link" target="_blank">NGINX Unit</a> : NGINX Unit est un environnement d'exécution d'applications web léger et polyvalent.
+* [Uvicorn](https://www.uvicorn.dev/)Â : un serveur ASGI haute performance.
+* [Hypercorn](https://hypercorn.readthedocs.io/) : un serveur ASGI compatible avec HTTP/2 et Trio entre autres fonctionnalités.
+* [Daphne](https://github.com/django/daphne) : le serveur ASGI conçu pour Django Channels.
+* [Granian](https://github.com/emmett-framework/granian)Â : un serveur HTTP Rust pour les applications Python.
+* [NGINX Unit](https://unit.nginx.org/howto/fastapi/) : NGINX Unit est un environnement d'exécution d'applications web léger et polyvalent.
## Machine serveur et programme serveur { #server-machine-and-server-program }
Mais vous pouvez Ă©galement installer un serveur ASGI manuellement.
-Vous devez créer un [environnement virtuel](../virtual-environments.md){.internal-link target=_blank}, l'activer, puis vous pouvez installer l'application serveur.
+Vous devez créer un [environnement virtuel](../virtual-environments.md), l'activer, puis vous pouvez installer l'application serveur.
Par exemple, pour installer Uvicorn :
* Sécurité - HTTPS
* Exécution au démarrage
* Redémarrages
-* Réplication (le nombre de processus en cours d'exécution)
+* **Réplication (le nombre de processus en cours d'exécution)**
* MĂ©moire
* Ătapes prĂ©alables avant le dĂ©marrage
Lors du dĂ©ploiement d'applications, vous voudrez probablement avoir une rĂ©plication de processus pour tirer parti de plusieurs cĆurs et pouvoir gĂ©rer davantage de requĂȘtes.
-Comme vous l'avez vu dans le chapitre précédent sur les [Concepts de déploiement](concepts.md){.internal-link target=_blank}, il existe plusieurs stratégies possibles.
+Comme vous l'avez vu dans le chapitre précédent sur les [Concepts de déploiement](concepts.md), il existe plusieurs stratégies possibles.
Ici, je vais vous montrer comment utiliser Uvicorn avec des processus workers en utilisant la commande `fastapi` ou directement la commande `uvicorn`.
/// info | Info
-Si vous utilisez des conteneurs, par exemple avec Docker ou Kubernetes, je vous en dirai plus Ă ce sujet dans le prochain chapitre : [FastAPI dans des conteneurs - Docker](docker.md){.internal-link target=_blank}.
+Si vous utilisez des conteneurs, par exemple avec Docker ou Kubernetes, je vous en dirai plus Ă ce sujet dans le prochain chapitre : [FastAPI dans des conteneurs - Docker](docker.md).
-En particulier, lorsque vous exécutez sur Kubernetes, vous ne voudrez probablement pas utiliser de workers et plutÎt exécuter un seul processus Uvicorn par conteneur, mais je vous en parlerai plus en détail dans ce chapitre.
+En particulier, lorsque vous exécutez sur **Kubernetes**, vous ne voudrez probablement **pas** utiliser de workers et plutÎt exécuter **un seul processus Uvicorn par conteneur**, mais je vous en parlerai plus en détail dans ce chapitre.
///
La seule option nouvelle ici est `--workers` qui indique à Uvicorn de démarrer 4 processus workers.
-Vous pouvez aussi voir qu'il affiche le PID de chaque processus, `27365` pour le processus parent (c'est le gestionnaire de processus) et un pour chaque processus worker : `27368`, `27369`, `27370` et `27367`.
+Vous pouvez aussi voir qu'il affiche le **PID** de chaque processus, `27365` pour le processus parent (c'est le **gestionnaire de processus**) et un pour chaque processus worker : `27368`, `27369`, `27370` et `27367`.
## Concepts de déploiement { #deployment-concepts }
Dans la liste des concepts de déploiement ci-dessus, l'utilisation de workers aide principalement à la partie réplication, et un peu aux redémarrages, mais vous devez toujours vous occuper des autres :
-* Sécurité - HTTPS
-* Exécution au démarrage
+* **Sécurité - HTTPS**
+* **Exécution au démarrage**
* ***Redémarrages***
* Réplication (le nombre de processus en cours d'exécution)
-* MĂ©moire
-* Ătapes prĂ©alables avant le dĂ©marrage
+* **MĂ©moire**
+* **Ătapes prĂ©alables avant le dĂ©marrage**
## Conteneurs et Docker { #containers-and-docker }
-Dans le prochain chapitre sur [FastAPI dans des conteneurs - Docker](docker.md){.internal-link target=_blank}, j'expliquerai quelques stratégies que vous pourriez utiliser pour gérer les autres concepts de déploiement.
+Dans le prochain chapitre sur [FastAPI dans des conteneurs - Docker](docker.md), j'expliquerai quelques stratégies que vous pourriez utiliser pour gérer les autres **concepts de déploiement**.
-Je vous montrerai comment créer votre propre image à partir de zéro pour exécuter un seul processus Uvicorn. C'est un processus simple et c'est probablement ce que vous voudrez faire lorsque vous utilisez un systÚme distribué de gestion de conteneurs comme Kubernetes.
+Je vous montrerai comment créer votre propre image à partir de zéro pour exécuter un seul processus Uvicorn. C'est un processus simple et c'est probablement ce que vous voudrez faire lorsque vous utilisez un systÚme distribué de gestion de conteneurs comme **Kubernetes**.
## RĂ©capitulatif { #recap }
-Vous pouvez utiliser plusieurs processus workers avec l'option CLI `--workers` des commandes `fastapi` ou `uvicorn` pour tirer parti des CPU multicĆurs, et exĂ©cuter plusieurs processus en parallĂšle.
+Vous pouvez utiliser plusieurs processus workers avec l'option CLI `--workers` des commandes `fastapi` ou `uvicorn` pour tirer parti des **CPU multicĆurs**, et exĂ©cuter **plusieurs processus en parallĂšle**.
Vous pourriez utiliser ces outils et idĂ©es si vous mettez en place votre propre systĂšme de dĂ©ploiement tout en prenant vous-mĂȘme en charge les autres concepts de dĂ©ploiement.
-Consultez le prochain chapitre pour en savoir plus sur FastAPI avec des conteneurs (par exemple Docker et Kubernetes). Vous verrez que ces outils offrent aussi des moyens simples de rĂ©soudre les autres concepts de dĂ©ploiement. âš
+Consultez le prochain chapitre pour en savoir plus sur **FastAPI** avec des conteneurs (par exemple Docker et Kubernetes). Vous verrez que ces outils offrent aussi des moyens simples de rĂ©soudre les autres **concepts de dĂ©ploiement**. âš
De nouvelles fonctionnalités sont ajoutées fréquemment, des bogues sont corrigés réguliÚrement et le code s'améliore continuellement.
-C'est pourquoi les versions actuelles sont toujours `0.x.x`, cela reflÚte que chaque version pourrait potentiellement comporter des changements non rétrocompatibles. Cela suit les conventions de <a href="https://semver.org/" class="external-link" target="_blank">versionnage sémantique</a>.
+C'est pourquoi les versions actuelles sont toujours `0.x.x`, cela reflÚte que chaque version pourrait potentiellement comporter des changements non rétrocompatibles. Cela suit les conventions de [versionnage sémantique](https://semver.org/).
Vous pouvez créer des applications de production avec **FastAPI** dÚs maintenant (et vous le faites probablement depuis un certain temps), vous devez juste vous assurer que vous utilisez une version qui fonctionne correctement avec le reste de votre code.
## Versions disponibles { #available-versions }
-Vous pouvez consulter les versions disponibles (par exemple, pour vérifier quelle est la derniÚre version en date) dans les [Notes de version](../release-notes.md){.internal-link target=_blank}.
+Vous pouvez consulter les versions disponibles (par exemple, pour vérifier quelle est la derniÚre version en date) dans les [Notes de version](../release-notes.md).
## Ă propos des versions { #about-versions }
Vous devez ajouter des tests pour votre application.
-Avec **FastAPI** c'est trĂšs facile (merci Ă Starlette), consultez les documents : [Tests](../tutorial/testing.md){.internal-link target=_blank}
+Avec **FastAPI** c'est trĂšs facile (merci Ă Starlette), consultez les documents : [Tests](../tutorial/testing.md)
AprÚs avoir des tests, vous pouvez mettre à niveau la version de **FastAPI** vers une version plus récente et vous assurer que tout votre code fonctionne correctement en exécutant vos tests.
/// tip | Astuce
-Le deuxiÚme argument de <a href="https://docs.python.org/3.8/library/os.html#os.getenv" class="external-link" target="_blank">`os.getenv()`</a> est la valeur par défaut à retourner.
+Le deuxiÚme argument de [`os.getenv()`](https://docs.python.org/3.8/library/os.html#os.getenv) est la valeur par défaut à retourner.
S'il n'est pas fourni, c'est `None` par défaut ; ici, nous fournissons `"World"` comme valeur par défaut à utiliser.
/// tip | Astuce
-Vous pouvez en lire davantage sur <a href="https://12factor.net/config" class="external-link" target="_blank">The Twelve-Factor App : Config</a>.
+Vous pouvez en lire davantage sur [The Twelve-Factor App : Config](https://12factor.net/config).
///
Cela signifie que **toute valeur** lue en Python Ă partir d'une variable d'environnement **sera une `str`**, et que toute conversion vers un autre type ou toute validation doit ĂȘtre effectuĂ©e dans le code.
-Vous en apprendrez davantage sur l'utilisation des variables d'environnement pour gérer les **paramÚtres d'application** dans le [Guide utilisateur avancé - ParamÚtres et variables d'environnement](./advanced/settings.md){.internal-link target=_blank}.
+Vous en apprendrez davantage sur l'utilisation des variables d'environnement pour gérer les **paramÚtres d'application** dans le [Guide utilisateur avancé - ParamÚtres et variables d'environnement](./advanced/settings.md).
## Variable d'environnement `PATH` { #path-environment-variable }
////
-Ces informations vous seront utiles lors de l'apprentissage des [Environnements virtuels](virtual-environments.md){.internal-link target=_blank}.
+Ces informations vous seront utiles lors de l'apprentissage des [Environnements virtuels](virtual-environments.md).
## Conclusion { #conclusion }
Avec cela, vous devriez avoir une compréhension de base de ce que sont les **variables d'environnement** et de la façon de les utiliser en Python.
-Vous pouvez également en lire davantage sur la <a href="https://en.wikipedia.org/wiki/Environment_variable" class="external-link" target="_blank">page Wikipédia dédiée aux variables d'environnement</a>.
+Vous pouvez également en lire davantage sur la [page Wikipédia dédiée aux variables d'environnement](https://en.wikipedia.org/wiki/Environment_variable).
Dans de nombreux cas, il n'est pas évident de voir immédiatement en quoi les variables d'environnement seraient utiles et applicables. Mais elles réapparaissent dans de nombreux scénarios lorsque vous développez, il est donc bon de les connaßtre.
# FastAPI CLI { #fastapi-cli }
-**FastAPI CLI** est un programme en ligne de commande que vous pouvez utiliser pour servir votre application FastAPI, gérer votre projet FastAPI, et plus encore.
+**FastAPI <abbr title="command line interface - interface en ligne de commande">CLI</abbr>** est un programme en ligne de commande que vous pouvez utiliser pour servir votre application FastAPI, gérer votre projet FastAPI, et plus encore.
-Lorsque vous installez FastAPI (par exemple avec `pip install "fastapi[standard]"`), cela inclut un package appelé `fastapi-cli` ; ce package fournit la commande `fastapi` dans le terminal.
+Lorsque vous installez FastAPI (par exemple avec `pip install "fastapi[standard]"`), il est fourni avec un programme en ligne de commande que vous pouvez exécuter dans le terminal.
Pour exécuter votre application FastAPI en développement, vous pouvez utiliser la commande `fastapi dev` :
<div class="termy">
```console
-$ <font color="#4E9A06">fastapi</font> dev <u style="text-decoration-style:solid">main.py</u>
+$ <font color="#4E9A06">fastapi</font> dev
<span style="background-color:#009485"><font color="#D3D7CF"> FastAPI </font></span> Starting development server đ
</div>
-Le programme en ligne de commande nommé `fastapi` est **FastAPI CLI**.
+/// tip | Astuce
+
+Pour la production, utilisez `fastapi run` plutĂŽt que `fastapi dev`. đ
+
+///
+
+En interne, **FastAPI CLI** utilise [Uvicorn](https://www.uvicorn.dev), un serveur ASGI haute performance, prĂȘt pour la production. đ
+
+La CLI `fastapi` tentera de dĂ©tecter automatiquement lâapplication FastAPI Ă exĂ©cuter, en supposant quâil sâagit dâun objet nommĂ© `app` dans un fichier `main.py` (ou quelques autres variantes).
+
+Mais vous pouvez configurer explicitement lâapplication Ă utiliser.
+
+## Configurer le `entrypoint` de lâapplication dans `pyproject.toml` { #configure-the-app-entrypoint-in-pyproject-toml }
+
+Vous pouvez configurer lâendroit oĂč se trouve votre application dans un fichier `pyproject.toml` comme suit :
+
+```toml
+[tool.fastapi]
+entrypoint = "main:app"
+```
+
+Cet `entrypoint` indiquera Ă la commande `fastapi` quâelle doit importer lâapplication comme ceci :
+
+```python
+from main import app
+```
-FastAPI CLI prend le chemin vers votre programme Python (par exemple `main.py`), dĂ©tecte automatiquement lâinstance `FastAPI` (gĂ©nĂ©ralement nommĂ©e `app`), dĂ©termine la procĂ©dure dâimportation correcte, puis la sert.
+Si votre code était structuré comme ceci :
+
+```
+.
+âââ backend
+â  âââ main.py
+â  âââ __init__.py
+```
+
+Vous définiriez alors le `entrypoint` comme suit :
+
+```toml
+[tool.fastapi]
+entrypoint = "backend.main:app"
+```
+
+ce qui serait Ă©quivalent Ă :
+
+```python
+from backend.main import app
+```
+
+### `fastapi dev` avec un chemin { #fastapi-dev-with-path }
+
+Vous pouvez Ă©galement passer le chemin du fichier Ă la commande `fastapi dev`, et elle devinera lâobjet dâapplication FastAPI Ă utiliser :
+
+```console
+$ fastapi dev main.py
+```
-Pour la production, vous utiliserez plutĂŽt `fastapi run`. đ
+Mais vous devez vous rappeler de passer le bon chemin Ă chaque fois que vous appelez la commande `fastapi`.
-En interne, **FastAPI CLI** utilise <a href="https://www.uvicorn.dev" class="external-link" target="_blank">Uvicorn</a>, un serveur ASGI haute performance, prĂȘt pour la production. đ
+De plus, dâautres outils pourraient ne pas pouvoir le trouver, par exemple lâ[extension VS Code](editor-support.md) ou [FastAPI Cloud](https://fastapicloud.com), il est donc recommandĂ© dâutiliser le `entrypoint` dans `pyproject.toml`.
## `fastapi dev` { #fastapi-dev }
/// tip | Astuce
-Vous pouvez en savoir plus à ce sujet dans la [documentation de déploiement](deployment/index.md){.internal-link target=_blank}.
+Vous pouvez en savoir plus à ce sujet dans la [documentation de déploiement](deployment/index.md).
///
### Basé sur des standards ouverts { #based-on-open-standards }
-* <a href="https://github.com/OAI/OpenAPI-Specification" class="external-link" target="_blank"><strong>OpenAPI</strong></a> pour la crĂ©ation d'API, incluant la dĂ©claration de <dfn title="aussi connu comme : endpoints, routes">chemin</dfn> <dfn title="aussi connu comme mĂ©thodes HTTP, comme POST, GET, PUT, DELETE">opĂ©rations</dfn>, paramĂštres, corps de requĂȘtes, sĂ©curitĂ©, etc.
-* Documentation automatique des modĂšles de donnĂ©es avec <a href="https://json-schema.org/" class="external-link" target="_blank"><strong>JSON Schema</strong></a> (puisque OpenAPI est lui-mĂȘme basĂ© sur JSON Schema).
+* [**OpenAPI**](https://github.com/OAI/OpenAPI-Specification) pour la crĂ©ation d'API, incluant la dĂ©claration de <dfn title="aussi connu comme : endpoints, routes">chemin</dfn> <dfn title="aussi connu comme mĂ©thodes HTTP, comme POST, GET, PUT, DELETE">opĂ©rations</dfn>, paramĂštres, corps de requĂȘtes, sĂ©curitĂ©, etc.
+* Documentation automatique des modĂšles de donnĂ©es avec [**JSON Schema**](https://json-schema.org/) (puisque OpenAPI est lui-mĂȘme basĂ© sur JSON Schema).
* Conçu autour de ces standards, aprÚs une étude méticuleuse. PlutÎt qu'une couche ajoutée aprÚs coup.
* Cela permet également d'utiliser la **génération automatique de code client** dans de nombreux langages.
Documentation d'API interactive et interfaces web d'exploration. Comme le framework est basé sur OpenAPI, plusieurs options existent, 2 incluses par défaut.
-* <a href="https://github.com/swagger-api/swagger-ui" class="external-link" target="_blank"><strong>Swagger UI</strong></a>, avec exploration interactive, appelez et testez votre API directement depuis le navigateur.
+* [**Swagger UI**](https://github.com/swagger-api/swagger-ui), avec exploration interactive, appelez et testez votre API directement depuis le navigateur.
-* Documentation d'API alternative avec <a href="https://github.com/Rebilly/ReDoc" class="external-link" target="_blank"><strong>ReDoc</strong></a>.
+* Documentation d'API alternative avec [**ReDoc**](https://github.com/Rebilly/ReDoc).
Tout est basé sur les déclarations de **types Python** standard (grùce à Pydantic). Aucune nouvelle syntaxe à apprendre. Juste du Python moderne standard.
-Si vous avez besoin d'un rappel de 2 minutes sur l'utilisation des types en Python (mĂȘme si vous n'utilisez pas FastAPI), consultez le court tutoriel : [Types Python](python-types.md){.internal-link target=_blank}.
+Si vous avez besoin d'un rappel de 2 minutes sur l'utilisation des types en Python (mĂȘme si vous n'utilisez pas FastAPI), consultez le court tutoriel : [Types Python](python-types.md).
Vous Ă©crivez du Python standard avec des types :
Tout le framework a Ă©tĂ© conçu pour ĂȘtre facile et intuitif Ă utiliser, toutes les dĂ©cisions ont Ă©tĂ© testĂ©es sur plusieurs Ă©diteurs avant mĂȘme de commencer le dĂ©veloppement, pour assurer la meilleure expĂ©rience de dĂ©veloppement.
-Dans les enquĂȘtes auprĂšs des dĂ©veloppeurs Python, il est clair <a href="https://www.jetbrains.com/research/python-developers-survey-2017/#tools-and-features" class="external-link" target="_blank">que lâune des fonctionnalitĂ©s les plus utilisĂ©es est « autocomplĂ©tion »</a>.
+Dans les enquĂȘtes auprĂšs des dĂ©veloppeurs Python, il est clair [que lâune des fonctionnalitĂ©s les plus utilisĂ©es est « autocomplĂ©tion »](https://www.jetbrains.com/research/python-developers-survey-2017/#tools-and-features).
L'ensemble du framework **FastAPI** est conçu pour satisfaire cela. L'autocomplétion fonctionne partout.
Voici comment votre Ă©diteur peut vous aider :
-* dans <a href="https://code.visualstudio.com/" class="external-link" target="_blank">Visual Studio Code</a> :
+* dans [Visual Studio Code](https://code.visualstudio.com/) :
-* dans <a href="https://www.jetbrains.com/pycharm/" class="external-link" target="_blank">PyCharm</a> :
+* dans [PyCharm](https://www.jetbrains.com/pycharm/) :
Tous les schémas de sécurité définis dans OpenAPI, y compris :
* HTTP Basic.
-* **OAuth2** (Ă©galement avec des **tokens JWT**). Consultez le tutoriel [OAuth2 avec JWT](tutorial/security/oauth2-jwt.md){.internal-link target=_blank}.
+* **OAuth2** (Ă©galement avec des **tokens JWT**). Consultez le tutoriel [OAuth2 avec JWT](tutorial/security/oauth2-jwt.md).
* Clés d'API dans :
* les en-tĂȘtes.
* les paramĂštres de requĂȘte.
## Fonctionnalités de Starlette { #starlette-features }
-**FastAPI** est entiÚrement compatible avec (et basé sur) <a href="https://www.starlette.dev/" class="external-link" target="_blank"><strong>Starlette</strong></a>. Donc, tout code Starlette additionnel que vous avez fonctionnera aussi.
+**FastAPI** est entiÚrement compatible avec (et basé sur) [**Starlette**](https://www.starlette.dev/). Donc, tout code Starlette additionnel que vous avez fonctionnera aussi.
`FastAPI` est en fait une sous-classe de `Starlette`. Ainsi, si vous connaissez ou utilisez dĂ©jĂ Starlette, la plupart des fonctionnalitĂ©s fonctionneront de la mĂȘme maniĂšre.
Avec **FastAPI** vous obtenez toutes les fonctionnalités de **Starlette** (puisque FastAPI est juste Starlette sous stéroïdes) :
-* Des performances vraiment impressionnantes. C'est <a href="https://github.com/encode/starlette#performance" class="external-link" target="_blank">lâun des frameworks Python les plus rapides disponibles, Ă lâĂ©gal de **NodeJS** et **Go**</a>.
+* Des performances vraiment impressionnantes. C'est [lâun des frameworks Python les plus rapides disponibles, Ă lâĂ©gal de **NodeJS** et **Go**](https://github.com/encode/starlette#performance).
* Prise en charge des **WebSocket**.
* TĂąches d'arriĂšre-plan dans le processus.
* ĂvĂšnements de dĂ©marrage et d'arrĂȘt.
## Fonctionnalités de Pydantic { #pydantic-features }
-**FastAPI** est entiÚrement compatible avec (et basé sur) <a href="https://docs.pydantic.dev/" class="external-link" target="_blank"><strong>Pydantic</strong></a>. Donc, tout code Pydantic additionnel que vous avez fonctionnera aussi.
+**FastAPI** est entiÚrement compatible avec (et basé sur) [**Pydantic**](https://docs.pydantic.dev/). Donc, tout code Pydantic additionnel que vous avez fonctionnera aussi.
Y compris des bibliothĂšques externes Ă©galement basĂ©es sur Pydantic, servant dâ<abbr title="Object-Relational Mapper - Mappeur objet-relationnel">ORM</abbr>, dâ<abbr title="Object-Document Mapper - Mappeur objet-document">ODM</abbr> pour les bases de donnĂ©es.
## S'abonner Ă la newsletter { #subscribe-to-the-newsletter }
-Vous pouvez vous abonner à la (peu fréquente) [newsletter **FastAPI and friends**](newsletter.md){.internal-link target=_blank} pour rester informé à propos :
+Vous pouvez vous abonner à la (peu fréquente) [newsletter **FastAPI and friends**](newsletter.md) pour rester informé à propos :
* Nouvelles sur FastAPI et ses amis đ
* Guides đ
## Suivre FastAPI sur X (Twitter) { #follow-fastapi-on-x-twitter }
-<a href="https://x.com/fastapi" class="external-link" target="_blank">Suivez @fastapi sur **X (Twitter)**</a> pour obtenir les derniĂšres nouvelles sur **FastAPI**. đŠ
+[Suivez @fastapi sur **X (Twitter)**](https://x.com/fastapi) pour obtenir les derniĂšres nouvelles sur **FastAPI**. đŠ
## Mettre une Ă©toile Ă **FastAPI** sur GitHub { #star-fastapi-in-github }
-Vous pouvez « star » FastAPI sur GitHub (en cliquant sur le bouton Ă©toile en haut Ă droite) : <a href="https://github.com/fastapi/fastapi" class="external-link" target="_blank">https://github.com/fastapi/fastapi</a>. âïž
+Vous pouvez « star » FastAPI sur GitHub (en cliquant sur le bouton Ă©toile en haut Ă droite) : [https://github.com/fastapi/fastapi](https://github.com/fastapi/fastapi). âïž
En ajoutant une étoile, les autres utilisateurs pourront le trouver plus facilement et voir qu'il a déjà été utile à d'autres.
## Suivre le dépÎt GitHub pour les releases { #watch-the-github-repository-for-releases }
-Vous pouvez « watch » FastAPI sur GitHub (en cliquant sur le bouton « watch » en haut Ă droite) : <a href="https://github.com/fastapi/fastapi" class="external-link" target="_blank">https://github.com/fastapi/fastapi</a>. đ
+Vous pouvez « watch » FastAPI sur GitHub (en cliquant sur le bouton « watch » en haut Ă droite) : [https://github.com/fastapi/fastapi](https://github.com/fastapi/fastapi). đ
Vous pouvez y sélectionner « Releases only ».
## Entrer en contact avec l'auteur { #connect-with-the-author }
-Vous pouvez entrer en contact avec <a href="https://tiangolo.com" class="external-link" target="_blank">moi (SebastiĂĄn RamĂrez / `tiangolo`)</a>, l'auteur.
+Vous pouvez entrer en contact avec [moi (SebastiĂĄn RamĂrez / `tiangolo`)](https://tiangolo.com), l'auteur.
Vous pouvez :
-* <a href="https://github.com/tiangolo" class="external-link" target="_blank">Me suivre sur **GitHub**</a>.
+* [Me suivre sur **GitHub**](https://github.com/tiangolo).
* Voir d'autres projets Open Source que j'ai créés et qui pourraient vous aider.
* Me suivre pour voir quand je crée un nouveau projet Open Source.
-* <a href="https://x.com/tiangolo" class="external-link" target="_blank">Me suivre sur **X (Twitter)**</a> ou sur <a href="https://fosstodon.org/@tiangolo" class="external-link" target="_blank">Mastodon</a>.
+* [Me suivre sur **X (Twitter)**](https://x.com/tiangolo) ou sur [Mastodon](https://fosstodon.org/@tiangolo).
* Me dire comment vous utilisez FastAPI (j'adore l'entendre).
* Ătre informĂ© quand je fais des annonces ou publie de nouveaux outils.
- * Vous pouvez aussi <a href="https://x.com/fastapi" class="external-link" target="_blank">suivre @fastapi sur X (Twitter)</a> (un compte séparé).
-* <a href="https://www.linkedin.com/in/tiangolo/" class="external-link" target="_blank">Me suivre sur **LinkedIn**</a>.
+ * Vous pouvez aussi [suivre @fastapi sur X (Twitter)](https://x.com/fastapi) (un compte séparé).
+* [Me suivre sur **LinkedIn**](https://www.linkedin.com/in/tiangolo/).
* Ătre informĂ© quand je fais des annonces ou publie de nouveaux outils (mĂȘme si j'utilise plus souvent X (Twitter) đ€·ââ).
-* Lire ce que j'Ă©cris (ou me suivre) sur <a href="https://dev.to/tiangolo" class="external-link" target="_blank">**Dev.to**</a> ou <a href="https://medium.com/@tiangolo" class="external-link" target="_blank">**Medium**</a>.
+* Lire ce que j'Ă©cris (ou me suivre) sur [**Dev.to**](https://dev.to/tiangolo) ou [**Medium**](https://medium.com/@tiangolo).
* Lire d'autres idées, des articles, et découvrir des outils que j'ai créés.
* Me suivre pour lire quand je publie quelque chose de nouveau.
## Tweeter Ă propos de **FastAPI** { #tweet-about-fastapi }
-<a href="https://x.com/compose/tweet?text=I'm loving @fastapi because... https://github.com/fastapi/fastapi" class="external-link" target="_blank">Tweetez Ă propos de **FastAPI**</a> et faites savoir Ă moi et aux autres pourquoi vous l'apprĂ©ciez. đ
+[Tweetez Ă propos de **FastAPI**](https://x.com/compose/tweet?text=I'm loving @fastapi because... https://github.com/fastapi/fastapi) et faites savoir Ă moi et aux autres pourquoi vous l'apprĂ©ciez. đ
J'adore entendre comment **FastAPI** est utilisé, ce que vous avez aimé, dans quel projet/quelle entreprise vous l'utilisez, etc.
## Voter pour FastAPI { #vote-for-fastapi }
-* <a href="https://www.slant.co/options/34241/~fastapi-review" class="external-link" target="_blank">Votez pour **FastAPI** sur Slant</a>.
-* <a href="https://alternativeto.net/software/fastapi/about/" class="external-link" target="_blank">Votez pour **FastAPI** sur AlternativeTo</a>.
-* <a href="https://stackshare.io/pypi-fastapi" class="external-link" target="_blank">Indiquez que vous utilisez **FastAPI** sur StackShare</a>.
+* [Votez pour **FastAPI** sur Slant](https://www.slant.co/options/34241/~fastapi-review).
+* [Votez pour **FastAPI** sur AlternativeTo](https://alternativeto.net/software/fastapi/about/).
+* [Indiquez que vous utilisez **FastAPI** sur StackShare](https://stackshare.io/pypi-fastapi).
## Aider les autres avec des questions sur GitHub { #help-others-with-questions-in-github }
Vous pouvez essayer d'aider les autres avec leurs questions dans :
-* <a href="https://github.com/fastapi/fastapi/discussions/categories/questions?discussions_q=category%3AQuestions+is%3Aunanswered" class="external-link" target="_blank">GitHub Discussions</a>
-* <a href="https://github.com/fastapi/fastapi/issues?q=is%3Aissue+is%3Aopen+sort%3Aupdated-desc+label%3Aquestion+-label%3Aanswered+" class="external-link" target="_blank">GitHub Issues</a>
+* [GitHub Discussions](https://github.com/fastapi/fastapi/discussions/categories/questions?discussions_q=category%3AQuestions+is%3Aunanswered)
+* [GitHub Issues](https://github.com/fastapi/fastapi/issues?q=is%3Aissue+is%3Aopen+sort%3Aupdated-desc+label%3Aquestion+-label%3Aanswered+)
Dans de nombreux cas, vous connaissez peut-ĂȘtre dĂ©jĂ la rĂ©ponse Ă ces questions. đ€
-Si vous aidez beaucoup de personnes avec leurs questions, vous deviendrez un [Expert FastAPI](fastapi-people.md#fastapi-experts){.internal-link target=_blank} officiel. đ
+Si vous aidez beaucoup de personnes avec leurs questions, vous deviendrez un [Expert FastAPI](fastapi-people.md#fastapi-experts) officiel. đ
N'oubliez pas, le point le plus important est : essayez d'ĂȘtre aimable. Les gens viennent avec leurs frustrations et, dans bien des cas, ne posent pas la question de la meilleure façon, mais faites de votre mieux pour rester aimable. đ€
Dans de nombreux cas, elle ne copiera qu'un fragment de code, mais ce n'est pas suffisant pour **reproduire le problĂšme**.
-* Vous pouvez leur demander de fournir un <a href="https://stackoverflow.com/help/minimal-reproducible-example" class="external-link" target="_blank">exemple minimal, complet et vĂ©rifiable</a>, que vous pouvez **copierâcoller** et exĂ©cuter localement pour voir la mĂȘme erreur ou le mĂȘme comportement qu'ils observent, ou pour mieux comprendre leur cas d'utilisation.
+* Vous pouvez leur demander de fournir un [exemple minimal, complet et vĂ©rifiable](https://stackoverflow.com/help/minimal-reproducible-example), que vous pouvez **copierâcoller** et exĂ©cuter localement pour voir la mĂȘme erreur ou le mĂȘme comportement qu'ils observent, ou pour mieux comprendre leur cas d'utilisation.
* Si vous vous sentez trĂšs gĂ©nĂ©reux, vous pouvez essayer de **crĂ©er un tel exemple** vousâmĂȘme, simplement Ă partir de la description du problĂšme. Gardez simplement Ă l'esprit que cela peut prendre beaucoup de temps et qu'il peut ĂȘtre prĂ©fĂ©rable de leur demander d'abord de clarifier le problĂšme.
## Suivre le dépÎt GitHub { #watch-the-github-repository }
-Vous pouvez « watch » FastAPI sur GitHub (en cliquant sur le bouton « watch » en haut Ă droite) : <a href="https://github.com/fastapi/fastapi" class="external-link" target="_blank">https://github.com/fastapi/fastapi</a>. đ
+Vous pouvez « watch » FastAPI sur GitHub (en cliquant sur le bouton « watch » en haut Ă droite) : [https://github.com/fastapi/fastapi](https://github.com/fastapi/fastapi). đ
Si vous sĂ©lectionnez « Watching » au lieu de « Releases only », vous recevrez des notifications lorsque quelqu'un crĂ©e une nouvelle issue ou question. Vous pouvez aussi prĂ©ciser que vous ne souhaitez ĂȘtre notifiĂ© que pour les nouvelles issues, ou les discussions, ou les PR, etc.
## Poser des questions { #ask-questions }
-Vous pouvez <a href="https://github.com/fastapi/fastapi/discussions/new?category=questions" class="external-link" target="_blank">créer une nouvelle question</a> dans le dépÎt GitHub, par exemple pour :
+Vous pouvez [créer une nouvelle question](https://github.com/fastapi/fastapi/discussions/new?category=questions) dans le dépÎt GitHub, par exemple pour :
* Poser une **question** ou demander Ă propos d'un **problĂšme**.
* Suggérer une nouvelle **fonctionnalité**.
## Créer une Pull Request { #create-a-pull-request }
-Vous pouvez [contribuer](contributing.md){.internal-link target=_blank} au code source avec des Pull Requests, par exemple :
+Vous pouvez [contribuer](contributing.md) au code source avec des Pull Requests, par exemple :
* Corriger une coquille que vous avez trouvée dans la documentation.
-* Partager un article, une vidéo ou un podcast que vous avez créé ou trouvé à propos de FastAPI en <a href="https://github.com/fastapi/fastapi/edit/master/docs/en/data/external_links.yml" class="external-link" target="_blank">modifiant ce fichier</a>.
+* Partager un article, une vidéo ou un podcast que vous avez créé ou trouvé à propos de FastAPI en [modifiant ce fichier](https://github.com/fastapi/fastapi/edit/master/docs/en/data/external_links.yml).
* Vous devez vous assurer d'ajouter votre lien au début de la section correspondante.
-* Aider Ă [traduire la documentation](contributing.md#translations){.internal-link target=_blank} dans votre langue.
+* Aider Ă [traduire la documentation](contributing.md#translations) dans votre langue.
* Vous pouvez aussi aider à relire les traductions créées par d'autres.
* Proposer de nouvelles sections de documentation.
* Corriger une issue/un bug existant.
Les principales tùches que vous pouvez faire dÚs maintenant sont :
-* [Aider les autres avec des questions sur GitHub](#help-others-with-questions-in-github){.internal-link target=_blank} (voir la section ciâdessus).
-* [Relire des Pull Requests](#review-pull-requests){.internal-link target=_blank} (voir la section ciâdessus).
+* [Aider les autres avec des questions sur GitHub](#help-others-with-questions-in-github) (voir la section ciâdessus).
+* [Relire des Pull Requests](#review-pull-requests) (voir la section ciâdessus).
Ces deux tĂąches sont celles qui **consomment le plus de temps**. C'est le travail principal de la maintenance de FastAPI.
## Rejoindre le chat { #join-the-chat }
-Rejoignez le đ„ <a href="https://discord.gg/VQjSZaeJmf" class="external-link" target="_blank">serveur Discord</a> đ„ et Ă©changez avec d'autres membres de la communautĂ© FastAPI.
+Rejoignez le đ„ [serveur Discord](https://discord.gg/VQjSZaeJmf) đ„ et Ă©changez avec d'autres membres de la communautĂ© FastAPI.
/// tip | Astuce
-Pour les questions, posezâles dans <a href="https://github.com/fastapi/fastapi/discussions/new?category=questions" class="external-link" target="_blank">GitHub Discussions</a>, vous avez bien plus de chances de recevoir de l'aide par les [Experts FastAPI](fastapi-people.md#fastapi-experts){.internal-link target=_blank}.
+Pour les questions, posezâles dans [GitHub Discussions](https://github.com/fastapi/fastapi/discussions/new?category=questions), vous avez bien plus de chances de recevoir de l'aide par les [Experts FastAPI](fastapi-people.md#fastapi-experts).
Utilisez le chat uniquement pour d'autres conversations générales.
Sur GitHub, le modĂšle vous guidera pour rĂ©diger la bonne question afin que vous puissiez plus facilement obtenir une bonne rĂ©ponse, ou mĂȘme rĂ©soudre le problĂšme vousâmĂȘme avant de demander. Et sur GitHub, je peux m'assurer de toujours tout rĂ©pondre, mĂȘme si cela prend du temps. Je ne peux pas personnellement faire cela avec les systĂšmes de chat. đ
-Les conversations dans les systÚmes de chat ne sont pas non plus aussi facilement recherchables que sur GitHub, donc les questions et réponses peuvent se perdre dans la conversation. Et seules celles sur GitHub comptent pour devenir un [Expert FastAPI](fastapi-people.md#fastapi-experts){.internal-link target=_blank}, vous aurez donc trÚs probablement plus d'attention sur GitHub.
+Les conversations dans les systÚmes de chat ne sont pas non plus aussi facilement recherchables que sur GitHub, donc les questions et réponses peuvent se perdre dans la conversation. Et seules celles sur GitHub comptent pour devenir un [Expert FastAPI](fastapi-people.md#fastapi-experts), vous aurez donc trÚs probablement plus d'attention sur GitHub.
D'un autre cĂŽtĂ©, il y a des milliers d'utilisateurs dans les systĂšmes de chat, il y a donc de fortes chances que vous trouviez presque toujours quelqu'un avec qui parler. đ
## Sponsoriser l'auteur { #sponsor-the-author }
-Si votre **produit/entreprise** dĂ©pend de **FastAPI** ou y est liĂ© et que vous souhaitez atteindre ses utilisateurs, vous pouvez sponsoriser l'auteur (moi) via <a href="https://github.com/sponsors/tiangolo" class="external-link" target="_blank">GitHub sponsors</a>. Selon le niveau, vous pourriez obtenir des avantages supplĂ©mentaires, comme un badge dans la documentation. đ
+Si votre **produit/entreprise** dĂ©pend de **FastAPI** ou y est liĂ© et que vous souhaitez atteindre ses utilisateurs, vous pouvez sponsoriser l'auteur (moi) via [GitHub sponsors](https://github.com/sponsors/tiangolo). Selon le niveau, vous pourriez obtenir des avantages supplĂ©mentaires, comme un badge dans les documents. đ
---
# Histoire, conception et avenir { #history-design-and-future }
-Il y a quelque temps, <a href="https://github.com/fastapi/fastapi/issues/3#issuecomment-454956920" class="external-link" target="_blank">un utilisateur de **FastAPI** a demandé</a> :
+Il y a quelque temps, [un utilisateur de **FastAPI** a demandé](https://github.com/fastapi/fastapi/issues/3#issuecomment-454956920) :
> Quelle est l'histoire de ce projet ? Il semble ĂȘtre sorti de nulle part et est devenu gĂ©nial en quelques semaines [...].
L'histoire de **FastAPI** est en grande partie l'histoire de ses prédécesseurs.
-Comme dit dans la section [Alternatives](alternatives.md){.internal-link target=_blank} :
+Comme dit dans la section [Alternatives](alternatives.md) :
<blockquote markdown="1">
J'ai testé plusieurs idées dans les éditeurs Python les plus populaires : PyCharm, VS Code, les éditeurs basés sur Jedi.
-D'aprĂšs la derniĂšre <a href="https://www.jetbrains.com/research/python-developers-survey-2018/#development-tools" class="external-link" target="_blank">EnquĂȘte DĂ©veloppeurs Python</a>, cela couvre environ 80% des utilisateurs.
+D'aprĂšs la derniĂšre [EnquĂȘte DĂ©veloppeurs Python](https://www.jetbrains.com/research/python-developers-survey-2018/#development-tools), cela couvre environ 80% des utilisateurs.
Cela signifie que **FastAPI** a été spécifiquement testé avec les éditeurs utilisés par 80% des développeurs Python. Et comme la plupart des autres éditeurs ont tendance à fonctionner de façon similaire, tous ses avantages devraient fonctionner pour pratiquement tous les éditeurs.
## Exigences { #requirements }
-AprÚs avoir testé plusieurs alternatives, j'ai décidé que j'allais utiliser <a href="https://docs.pydantic.dev/" class="external-link" target="_blank">**Pydantic**</a> pour ses avantages.
+AprÚs avoir testé plusieurs alternatives, j'ai décidé que j'allais utiliser [**Pydantic**](https://docs.pydantic.dev/) pour ses avantages.
J'y ai ensuite contribué, pour le rendre entiÚrement compatible avec JSON Schema, pour supporter différentes maniÚres de définir les déclarations de contraintes, et pour améliorer le support des éditeurs (vérifications de type, autocomplétion) sur la base des tests effectués dans plusieurs éditeurs.
-Pendant le développement, j'ai également contribué à <a href="https://www.starlette.dev/" class="external-link" target="_blank">**Starlette**</a>, l'autre exigence clé.
+Pendant le développement, j'ai également contribué à [**Starlette**](https://www.starlette.dev/), l'autre exigence clé.
## DĂ©veloppement { #development }
**FastAPI** a un grand avenir devant lui.
-Et [votre aide](help-fastapi.md){.internal-link target=_blank} est grandement appréciée.
+Et [votre aide](help-fastapi.md) est grandement appréciée.
Avant FastAPI version `0.122.0`, lorsque les utilitaires de sécurité intégrés renvoyaient une erreur au client aprÚs un échec d'authentification, ils utilisaient le code d'état HTTP `403 Forbidden`.
-Ă partir de FastAPI version `0.122.0`, ils utilisent le code d'Ă©tat HTTP plus appropriĂ© `401 Unauthorized`, et renvoient un en-tĂȘte `WWW-Authenticate` pertinent dans la rĂ©ponse, conformĂ©ment aux spĂ©cifications HTTP, <a href="https://datatracker.ietf.org/doc/html/rfc7235#section-3.1" class="external-link" target="_blank">RFC 7235</a>, <a href="https://datatracker.ietf.org/doc/html/rfc9110#name-401-unauthorized" class="external-link" target="_blank">RFC 9110</a>.
+Ă partir de FastAPI version `0.122.0`, ils utilisent le code d'Ă©tat HTTP plus appropriĂ© `401 Unauthorized`, et renvoient un en-tĂȘte `WWW-Authenticate` pertinent dans la rĂ©ponse, conformĂ©ment aux spĂ©cifications HTTP, [RFC 7235](https://datatracker.ietf.org/doc/html/rfc7235#section-3.1), [RFC 9110](https://datatracker.ietf.org/doc/html/rfc9110#name-401-unauthorized).
Mais si, pour une raison quelconque, vos clients dépendent de l'ancien comportement, vous pouvez y revenir en surchargeant la méthode `make_not_authenticated_error` dans vos classes de sécurité.
Si nĂ©cessaire, vous pouvez utiliser des paramĂštres et des variables d'environnement pour configurer OpenAPI de maniĂšre conditionnelle selon l'environnement, et mĂȘme le dĂ©sactiver complĂštement.
-## à propos de la sécurité, des API et de la documentation { #about-security-apis-and-docs }
+## à propos de la sécurité, des API et des documents { #about-security-apis-and-docs }
-Masquer vos interfaces utilisateur de la documentation en production ne devrait pas ĂȘtre la maniĂšre de protĂ©ger votre API.
+Masquer vos interfaces utilisateur des documents en production ne devrait pas ĂȘtre la maniĂšre de protĂ©ger votre API.
Cela n'ajoute aucune sĂ©curitĂ© supplĂ©mentaire Ă votre API, les *chemins d'accĂšs* resteront disponibles lĂ oĂč ils se trouvent.
S'il y a une faille de sécurité dans votre code, elle existera toujours.
-Masquer la documentation rend simplement plus difficile la comprĂ©hension de la maniĂšre d'interagir avec votre API et pourrait aussi rendre son dĂ©bogage en production plus difficile. Cela pourrait ĂȘtre considĂ©rĂ© simplement comme une forme de <a href="https://en.wikipedia.org/wiki/Security_through_obscurity" class="external-link" target="_blank">SĂ©curitĂ© par l'obscuritĂ©</a>.
+Masquer les documents rend simplement plus difficile la comprĂ©hension de la maniĂšre d'interagir avec votre API et pourrait aussi rendre son dĂ©bogage en production plus difficile. Cela pourrait ĂȘtre considĂ©rĂ© simplement comme une forme de [SĂ©curitĂ© par l'obscuritĂ©](https://en.wikipedia.org/wiki/Security_through_obscurity).
Si vous voulez sécuriser votre API, il y a plusieurs meilleures approches possibles, par exemple :
* Ajoutez des contrÎles d'autorisation plus granulaires avec des scopes OAuth2 lorsque nécessaire.
* ... etc.
-NĂ©anmoins, vous pourriez avoir un cas d'utilisation trĂšs spĂ©cifique oĂč vous devez vraiment dĂ©sactiver la documentation de l'API pour un certain environnement (par exemple pour la production) ou selon des configurations provenant de variables d'environnement.
+NĂ©anmoins, vous pourriez avoir un cas d'utilisation trĂšs spĂ©cifique oĂč vous devez vraiment dĂ©sactiver les documents de l'API pour un certain environnement (par exemple pour la production) ou selon des configurations provenant de variables d'environnement.
## Configurer OpenAPI de maniĂšre conditionnelle avec des paramĂštres et des variables d'environnement { #conditional-openapi-from-settings-and-env-vars }
-Vous pouvez facilement utiliser les mĂȘmes paramĂštres Pydantic pour configurer votre OpenAPI gĂ©nĂ©rĂ© et les interfaces utilisateur de la documentation.
+Vous pouvez facilement utiliser les mĂȘmes paramĂštres Pydantic pour configurer votre OpenAPI gĂ©nĂ©rĂ© et les interfaces utilisateur des documents.
Par exemple :
Nous l'utilisons ensuite lors de la création de l'application `FastAPI`.
-Vous pouvez alors désactiver OpenAPI (y compris les interfaces utilisateur de la documentation) en définissant la variable d'environnement `OPENAPI_URL` sur la chaßne vide, comme ceci :
+Vous pouvez alors désactiver OpenAPI (y compris les interfaces utilisateur des documents) en définissant la variable d'environnement `OPENAPI_URL` sur la chaßne vide, comme ceci :
<div class="termy">
# Configurer Swagger UI { #configure-swagger-ui }
-Vous pouvez configurer des <a href="https://swagger.io/docs/open-source-tools/swagger-ui/usage/configuration/" class="external-link" target="_blank">paramÚtres supplémentaires de Swagger UI</a>.
+Vous pouvez configurer des [paramÚtres supplémentaires de Swagger UI](https://swagger.io/docs/open-source-tools/swagger-ui/usage/configuration/).
Pour les configurer, passez l'argument `swagger_ui_parameters` lors de la création de l'objet d'application `FastAPI()` ou à la fonction `get_swagger_ui_html()`.
## Autres paramĂštres de Swagger UI { #other-swagger-ui-parameters }
-Pour voir toutes les autres configurations possibles que vous pouvez utiliser, lisez la <a href="https://swagger.io/docs/open-source-tools/swagger-ui/usage/configuration/" class="external-link" target="_blank">documentation officielle des paramĂštres de Swagger UI</a>.
+Pour voir toutes les autres configurations possibles que vous pouvez utiliser, lisez les [documents officiels pour les paramĂštres de Swagger UI](https://swagger.io/docs/open-source-tools/swagger-ui/usage/configuration/).
## ParamĂštres JavaScript uniquement { #javascript-only-settings }
### Tester { #test-it }
-Vous devriez maintenant pouvoir aller Ă vos docs sur <a href="http://127.0.0.1:8000/docs" class="external-link" target="_blank">http://127.0.0.1:8000/docs</a>, puis recharger la page : elle chargera ces ressources depuis le nouveau CDN.
+Vous devriez maintenant pouvoir aller Ă vos docs sur [http://127.0.0.1:8000/docs](http://127.0.0.1:8000/docs), puis recharger la page : elle chargera ces ressources depuis le nouveau CDN.
## HĂ©berger en propre JavaScript et CSS pour les docs { #self-hosting-javascript-and-css-for-docs }
**Swagger UI** utilise les fichiers :
-- <a href="https://cdn.jsdelivr.net/npm/swagger-ui-dist@5/swagger-ui-bundle.js" class="external-link" target="_blank">`swagger-ui-bundle.js`</a>
-- <a href="https://cdn.jsdelivr.net/npm/swagger-ui-dist@5/swagger-ui.css" class="external-link" target="_blank">`swagger-ui.css`</a>
+- [`swagger-ui-bundle.js`](https://cdn.jsdelivr.net/npm/swagger-ui-dist@5/swagger-ui-bundle.js)
+- [`swagger-ui.css`](https://cdn.jsdelivr.net/npm/swagger-ui-dist@5/swagger-ui.css)
Et **ReDoc** utilise le fichier :
-- <a href="https://cdn.jsdelivr.net/npm/redoc@2/bundles/redoc.standalone.js" class="external-link" target="_blank">`redoc.standalone.js`</a>
+- [`redoc.standalone.js`](https://cdn.jsdelivr.net/npm/redoc@2/bundles/redoc.standalone.js)
AprĂšs cela, votre structure de fichiers pourrait ressembler Ă :
### Tester les fichiers statiques { #test-the-static-files }
-DĂ©marrez votre application et rendezâvous sur <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>.
+DĂ©marrez votre application et rendezâvous sur [http://127.0.0.1:8000/static/redoc.standalone.js](http://127.0.0.1:8000/static/redoc.standalone.js).
Vous devriez voir un trĂšs long fichier JavaScript pour **ReDoc**.
### Tester lâUI avec des fichiers statiques { #test-static-files-ui }
-Vous devriez maintenant pouvoir couper votre WiâFi, aller Ă vos docs sur <a href="http://127.0.0.1:8000/docs" class="external-link" target="_blank">http://127.0.0.1:8000/docs</a> et recharger la page.
+Vous devriez maintenant pouvoir couper votre WiâFi, aller Ă vos docs sur [http://127.0.0.1:8000/docs](http://127.0.0.1:8000/docs) et recharger la page.
Et mĂȘme sans Internet, vous pourrez voir la documentation de votre API et interagir avec elle.
Voici quelques cas d'utilisation :
-* Convertir des corps de requĂȘte non JSON en JSON (par exemple <a href="https://msgpack.org/index.html" class="external-link" target="_blank">`msgpack`</a>).
+* Convertir des corps de requĂȘte non JSON en JSON (par exemple [`msgpack`](https://msgpack.org/index.html)).
* DĂ©compresser des corps de requĂȘte compressĂ©s en gzip.
* Journaliser automatiquement tous les corps de requĂȘte.
/// tip | Astuce
-Il s'agit d'un exemple simplifié pour montrer le fonctionnement ; si vous avez besoin de la prise en charge de Gzip, vous pouvez utiliser le [`GzipMiddleware`](../advanced/middleware.md#gzipmiddleware){.internal-link target=_blank} fourni.
+Il s'agit d'un exemple simplifié pour montrer le fonctionnement ; si vous avez besoin de la prise en charge de Gzip, vous pouvez utiliser le [`GzipMiddleware`](../advanced/middleware.md#gzipmiddleware) fourni.
///
Et ces deux éléments, `scope` et `receive`, sont ce dont on a besoin pour créer une nouvelle instance de `Request`.
-Pour en savoir plus sur `Request`, consultez <a href="https://www.starlette.dev/requests/" class="external-link" target="_blank">la documentation de Starlette sur les requĂȘtes</a>.
+Pour en savoir plus sur `Request`, consultez [la documentation de Starlette sur les requĂȘtes](https://www.starlette.dev/requests/).
///
/// tip | Astuce
-Pour rĂ©soudre ce mĂȘme problĂšme, il est probablement beaucoup plus simple d'utiliser `body` dans un gestionnaire personnalisĂ© pour `RequestValidationError` ([GĂ©rer les erreurs](../tutorial/handling-errors.md#use-the-requestvalidationerror-body){.internal-link target=_blank}).
+Pour rĂ©soudre ce mĂȘme problĂšme, il est probablement beaucoup plus simple d'utiliser `body` dans un gestionnaire personnalisĂ© pour `RequestValidationError` ([GĂ©rer les erreurs](../tutorial/handling-errors.md#use-the-requestvalidationerror-body)).
Mais cet exemple reste valable et montre comment interagir avec les composants internes.
En vous appuyant sur les informations ci-dessus, vous pouvez utiliser la mĂȘme fonction utilitaire pour gĂ©nĂ©rer le schĂ©ma OpenAPI et remplacer chaque partie dont vous avez besoin.
-Par exemple, ajoutons <a href="https://github.com/Rebilly/ReDoc/blob/master/docs/redoc-vendor-extensions.md#x-logo" class="external-link" target="_blank">lâextension OpenAPI de ReDoc pour inclure un logo personnalisĂ©</a>.
+Par exemple, ajoutons [lâextension OpenAPI de ReDoc pour inclure un logo personnalisĂ©](https://github.com/Rebilly/ReDoc/blob/master/docs/redoc-vendor-extensions.md#x-logo).
### **FastAPI** normal { #normal-fastapi }
### VĂ©rifier { #check-it }
-Une fois que vous allez sur <a href="http://127.0.0.1:8000/redoc" class="external-link" target="_blank">http://127.0.0.1:8000/redoc</a>, vous verrez que vous utilisez votre logo personnalisé (dans cet exemple, le logo de **FastAPI**) :
+Une fois que vous allez sur [http://127.0.0.1:8000/redoc](http://127.0.0.1:8000/redoc), vous verrez que vous utilisez votre logo personnalisé (dans cet exemple, le logo de **FastAPI**) :
<img src="/img/tutorial/extending-openapi/image01.png">
# Général - Guides pratiques - Recettes { #general-how-to-recipes }
-Voici plusieurs renvois vers d'autres endroits de la documentation, pour des questions générales ou fréquentes.
+Voici plusieurs renvois vers d'autres endroits dans les documents, pour des questions générales ou fréquentes.
## Filtrer des données - Sécurité { #filter-data-security }
-Pour vous assurer que vous ne renvoyez pas plus de données que nécessaire, lisez la documentation [Tutoriel - ModÚle de réponse - Type de retour](../tutorial/response-model.md){.internal-link target=_blank}.
+Pour vous assurer que vous ne renvoyez pas plus de données que nécessaire, lisez les documents [Tutoriel - ModÚle de réponse - Type de retour](../tutorial/response-model.md).
+
+## Optimiser la performance des réponses - ModÚle de réponse - Type de retour { #optimize-response-performance-response-model-return-type }
+
+Pour optimiser la performance lors du renvoi de données JSON, utilisez un type de retour ou un modÚle de réponse ; de cette façon, Pydantic prendra en charge la sérialisation en JSON cÎté Rust, sans passer par Python. Pour en savoir plus, lisez les documents [Tutoriel - ModÚle de réponse - Type de retour](../tutorial/response-model.md).
## Ătiquettes de documentation - OpenAPI { #documentation-tags-openapi }
-Pour ajouter des Ă©tiquettes Ă vos *chemins d'accĂšs* et les regrouper dans l'interface utilisateur de la documentation, lisez la documentation [Tutoriel - Configurations de chemin d'accĂšs - Tags](../tutorial/path-operation-configuration.md#tags){.internal-link target=_blank}.
+Pour ajouter des Ă©tiquettes Ă vos *chemins d'accĂšs* et les regrouper dans l'interface utilisateur de la documentation, lisez les documents [Tutoriel - Configurations de chemin d'accĂšs - Tags](../tutorial/path-operation-configuration.md#tags).
## Résumé et description de la documentation - OpenAPI { #documentation-summary-and-description-openapi }
-Pour ajouter un résumé et une description à vos *chemins d'accÚs* et les afficher dans l'interface utilisateur de la documentation, lisez la documentation [Tutoriel - Configurations de chemin d'accÚs - Résumé et description](../tutorial/path-operation-configuration.md#summary-and-description){.internal-link target=_blank}.
+Pour ajouter un résumé et une description à vos *chemins d'accÚs* et les afficher dans l'interface utilisateur de la documentation, lisez les documents [Tutoriel - Configurations de chemin d'accÚs - Résumé et description](../tutorial/path-operation-configuration.md#summary-and-description).
## Description de la réponse dans la documentation - OpenAPI { #documentation-response-description-openapi }
-Pour définir la description de la réponse, affichée dans l'interface utilisateur de la documentation, lisez la documentation [Tutoriel - Configurations de chemin d'accÚs - Description de la réponse](../tutorial/path-operation-configuration.md#response-description){.internal-link target=_blank}.
+Pour définir la description de la réponse, affichée dans l'interface utilisateur de la documentation, lisez les documents [Tutoriel - Configurations de chemin d'accÚs - Description de la réponse](../tutorial/path-operation-configuration.md#response-description).
## Déprécier un *chemin d'accÚs* dans la documentation - OpenAPI { #documentation-deprecate-a-path-operation-openapi }
-Pour déprécier un *chemin d'accÚs* et l'indiquer dans l'interface utilisateur de la documentation, lisez la documentation [Tutoriel - Configurations de chemin d'accÚs - Déprécier un chemin d'accÚs](../tutorial/path-operation-configuration.md#deprecate-a-path-operation){.internal-link target=_blank}.
+Pour déprécier un *chemin d'accÚs* et l'indiquer dans l'interface utilisateur de la documentation, lisez les documents [Tutoriel - Configurations de chemin d'accÚs - Dépréciation](../tutorial/path-operation-configuration.md#deprecate-a-path-operation).
## Convertir n'importe quelles données au format compatible JSON { #convert-any-data-to-json-compatible }
-Pour convertir des données vers un format compatible JSON, lisez la documentation [Tutoriel - Encodeur compatible JSON](../tutorial/encoder.md){.internal-link target=_blank}.
+Pour convertir des données vers un format compatible JSON, lisez les documents [Tutoriel - Encodeur compatible JSON](../tutorial/encoder.md).
## Métadonnées OpenAPI - Documentation { #openapi-metadata-docs }
-Pour ajouter des métadonnées à votre schéma OpenAPI, y compris une licence, une version, un contact, etc., lisez la documentation [Tutoriel - Métadonnées et URLs de la documentation](../tutorial/metadata.md){.internal-link target=_blank}.
+Pour ajouter des métadonnées à votre schéma OpenAPI, y compris une licence, une version, un contact, etc., lisez les documents [Tutoriel - Métadonnées et URLs de la documentation](../tutorial/metadata.md).
## URL OpenAPI personnalisée { #openapi-custom-url }
-Pour personnaliser l'URL OpenAPI (ou la supprimer), lisez la documentation [Tutoriel - Métadonnées et URLs de la documentation](../tutorial/metadata.md#openapi-url){.internal-link target=_blank}.
+Pour personnaliser l'URL OpenAPI (ou la supprimer), lisez les documents [Tutoriel - Métadonnées et URLs de la documentation](../tutorial/metadata.md#openapi-url).
## URL de la documentation OpenAPI { #openapi-docs-urls }
-Pour mettre à jour les URL utilisées pour les interfaces utilisateur de documentation générées automatiquement, lisez la documentation [Tutoriel - Métadonnées et URLs de la documentation](../tutorial/metadata.md#docs-urls){.internal-link target=_blank}.
+Pour mettre à jour les URL utilisées pour les interfaces utilisateur de documentation générées automatiquement, lisez les documents [Tutoriel - Métadonnées et URLs de la documentation](../tutorial/metadata.md#docs-urls).
Voici quelques bibliothĂšques **GraphQL** qui prennent en charge **ASGI**. Vous pouvez les utiliser avec **FastAPI** :
-* <a href="https://strawberry.rocks/" class="external-link" target="_blank">Strawberry</a> đ
- * Avec <a href="https://strawberry.rocks/docs/integrations/fastapi" class="external-link" target="_blank">la documentation pour FastAPI</a>
-* <a href="https://ariadnegraphql.org/" class="external-link" target="_blank">Ariadne</a>
- * Avec <a href="https://ariadnegraphql.org/docs/fastapi-integration" class="external-link" target="_blank">la documentation pour FastAPI</a>
-* <a href="https://tartiflette.io/" class="external-link" target="_blank">Tartiflette</a>
- * Avec <a href="https://tartiflette.github.io/tartiflette-asgi/" class="external-link" target="_blank">Tartiflette ASGI</a> pour fournir l'intégration ASGI
-* <a href="https://graphene-python.org/" class="external-link" target="_blank">Graphene</a>
- * Avec <a href="https://github.com/ciscorn/starlette-graphene3" class="external-link" target="_blank">starlette-graphene3</a>
+* [Strawberry](https://strawberry.rocks/) đ
+ * Avec [la documentation pour FastAPI](https://strawberry.rocks/docs/integrations/fastapi)
+* [Ariadne](https://ariadnegraphql.org/)
+ * Avec [la documentation pour FastAPI](https://ariadnegraphql.org/docs/fastapi-integration)
+* [Tartiflette](https://tartiflette.io/)
+ * Avec [Tartiflette ASGI](https://tartiflette.github.io/tartiflette-asgi/) pour fournir l'intégration ASGI
+* [Graphene](https://graphene-python.org/)
+ * Avec [starlette-graphene3](https://github.com/ciscorn/starlette-graphene3)
## GraphQL avec Strawberry { #graphql-with-strawberry }
-Si vous avez besoin ou souhaitez travailler avec **GraphQL**, <a href="https://strawberry.rocks/" class="external-link" target="_blank">**Strawberry**</a> est la bibliothÚque **recommandée** car sa conception est la plus proche de celle de **FastAPI**, tout est basé sur des **annotations de type**.
+Si vous avez besoin ou souhaitez travailler avec **GraphQL**, [**Strawberry**](https://strawberry.rocks/) est la bibliothÚque **recommandée** car sa conception est la plus proche de celle de **FastAPI**, tout est basé sur des **annotations de type**.
Selon votre cas d'utilisation, vous pourriez préférer une autre bibliothÚque, mais si vous me le demandiez, je vous suggérerais probablement d'essayer **Strawberry**.
{* ../../docs_src/graphql_/tutorial001_py310.py hl[3,22,25] *}
-Vous pouvez en apprendre davantage sur Strawberry dans la <a href="https://strawberry.rocks/" class="external-link" target="_blank">documentation de Strawberry</a>.
+Vous pouvez en apprendre davantage sur Strawberry dans la [documentation de Strawberry](https://strawberry.rocks/).
-Et Ă©galement la documentation sur <a href="https://strawberry.rocks/docs/integrations/fastapi" class="external-link" target="_blank">Strawberry avec FastAPI</a>.
+Et Ă©galement la documentation sur [Strawberry avec FastAPI](https://strawberry.rocks/docs/integrations/fastapi).
## Ancien `GraphQLApp` de Starlette { #older-graphqlapp-from-starlette }
-Les versions précédentes de Starlette incluaient une classe `GraphQLApp` pour s'intégrer à <a href="https://graphene-python.org/" class="external-link" target="_blank">Graphene</a>.
+Les versions précédentes de Starlette incluaient une classe `GraphQLApp` pour s'intégrer à [Graphene](https://graphene-python.org/).
-Elle a Ă©tĂ© dĂ©prĂ©ciĂ©e dans Starlette, mais si vous avez du code qui l'utilisait, vous pouvez facilement **migrer** vers <a href="https://github.com/ciscorn/starlette-graphene3" class="external-link" target="_blank">starlette-graphene3</a>, qui couvre le mĂȘme cas d'utilisation et propose une **interface presque identique**.
+Elle a Ă©tĂ© dĂ©prĂ©ciĂ©e dans Starlette, mais si vous avez du code qui l'utilisait, vous pouvez facilement **migrer** vers [starlette-graphene3](https://github.com/ciscorn/starlette-graphene3), qui couvre le mĂȘme cas d'utilisation et propose une **interface presque identique**.
/// tip | Astuce
-Si vous avez besoin de GraphQL, je vous recommande tout de mĂȘme de regarder <a href="https://strawberry.rocks/" class="external-link" target="_blank">Strawberry</a>, car il est basĂ© sur des annotations de type plutĂŽt que sur des classes et types personnalisĂ©s.
+Si vous avez besoin de GraphQL, je vous recommande tout de mĂȘme de regarder [Strawberry](https://strawberry.rocks/), car il est basĂ© sur des annotations de type plutĂŽt que sur des classes et types personnalisĂ©s.
///
## En savoir plus { #learn-more }
-Vous pouvez en apprendre davantage sur **GraphQL** dans la <a href="https://graphql.org/" class="external-link" target="_blank">documentation officielle de GraphQL</a>.
+Vous pouvez en apprendre davantage sur **GraphQL** dans la [documentation officielle de GraphQL](https://graphql.org/).
Vous pouvez également en lire davantage sur chacune des bibliothÚques décrites ci-dessus via leurs liens.
/// tip | Astuce
-Si vous voulez **apprendre FastAPI** de façon structurée (recommandé), allez lire le [Tutoriel - Guide utilisateur](../tutorial/index.md){.internal-link target=_blank} chapitre par chapitre à la place.
+Si vous voulez **apprendre FastAPI** de façon structurée (recommandé), allez lire le [Tutoriel - Guide utilisateur](../tutorial/index.md) chapitre par chapitre à la place.
///
/// warning | Alertes
-L'Ă©quipe Pydantic a arrĂȘtĂ© la prise en charge de Pydantic v1 pour les derniĂšres versions de Python, Ă partir de Python 3.14.
+L'Ă©quipe Pydantic a arrĂȘtĂ© la prise en charge de Pydantic v1 pour les derniĂšres versions de Python, Ă partir de **Python 3.14**.
-Cela inclut `pydantic.v1`, qui n'est plus pris en charge Ă partir de Python 3.14.
+Cela inclut `pydantic.v1`, qui n'est plus pris en charge en Python 3.14 et versions ultérieures.
Si vous souhaitez utiliser les derniÚres fonctionnalités de Python, vous devez vous assurer que vous utilisez Pydantic v2.
///
-Si vous avez une ancienne application FastAPI avec Pydantic v1, je vais vous montrer comment la migrer vers Pydantic v2, et les fonctionnalités de FastAPI 0.119.0 pour vous aider à une migration progressive.
+Si vous avez une ancienne application FastAPI avec Pydantic v1, je vais vous montrer comment la migrer vers Pydantic v2, et les **fonctionnalités de FastAPI 0.119.0** pour vous aider à une migration progressive.
## Guide officiel { #official-guide }
-Pydantic propose un <a href="https://docs.pydantic.dev/latest/migration/" class="external-link" target="_blank">Guide de migration</a> officiel de la v1 Ă la v2.
+Pydantic propose un [Guide de migration](https://docs.pydantic.dev/latest/migration/) officiel de la v1 Ă la v2.
Il inclut aussi ce qui a changé, comment les validations sont désormais plus correctes et strictes, les piÚges possibles, etc.
## Tests { #tests }
-Vous devez vous assurer d'avoir des [tests](../tutorial/testing.md){.internal-link target=_blank} pour votre application et de les exécuter en intégration continue (CI).
+Vous devez vous assurer d'avoir des [tests](../tutorial/testing.md) pour votre application et de les exécuter en intégration continue (CI).
De cette façon, vous pouvez effectuer la mise à niveau et vous assurer que tout fonctionne toujours comme prévu.
Dans de nombreux cas, lorsque vous utilisez des modĂšles Pydantic classiques sans personnalisations, vous pourrez automatiser la majeure partie du processus de migration de Pydantic v1 Ă Pydantic v2.
-Vous pouvez utiliser <a href="https://github.com/pydantic/bump-pydantic" class="external-link" target="_blank">`bump-pydantic`</a> de la mĂȘme Ă©quipe Pydantic.
+Vous pouvez utiliser [`bump-pydantic`](https://github.com/pydantic/bump-pydantic) de la mĂȘme Ă©quipe Pydantic.
Cet outil vous aidera Ă modifier automatiquement la majeure partie du code Ă adapter.
/// warning | Alertes
-Gardez à l'esprit que, puisque l'équipe Pydantic ne prend plus en charge Pydantic v1 dans les versions récentes de Python à partir de Python 3.14, l'utilisation de `pydantic.v1` n'est pas non plus prise en charge à partir de Python 3.14.
+Gardez à l'esprit que, puisque l'équipe Pydantic ne prend plus en charge Pydantic v1 dans les versions récentes de Python à partir de Python 3.14, l'utilisation de `pydantic.v1` n'est pas non plus prise en charge en Python 3.14 et versions ultérieures.
///
style V2Field fill:#f9fff3
```
-Dans certains cas, il est mĂȘme possible d'avoir des modĂšles Pydantic v1 et v2 dans le mĂȘme chemin d'accĂšs de votre application FastAPI :
+Dans certains cas, il est mĂȘme possible d'avoir des modĂšles Pydantic v1 et v2 dans le mĂȘme **chemin d'accĂšs** de votre application FastAPI :
{* ../../docs_src/pydantic_v1_in_v2/tutorial003_an_py310.py hl[2:3,6,12,21:22] *}
# Tester une base de données { #testing-a-database }
-Vous pouvez Ă©tudier les bases de donnĂ©es, SQL et SQLModel dans <a href="https://sqlmodel.tiangolo.com/" class="external-link" target="_blank">les documents SQLModel</a>. đ€
+Vous pouvez Ă©tudier les bases de donnĂ©es, SQL et SQLModel dans les [documents SQLModel](https://sqlmodel.tiangolo.com/). đ€
-Il existe un mini <a href="https://sqlmodel.tiangolo.com/tutorial/fastapi/" class="external-link" target="_blank">tutoriel sur l'utilisation de SQLModel avec FastAPI</a>. âš
+Il existe un mini [tutoriel sur l'utilisation de SQLModel avec FastAPI](https://sqlmodel.tiangolo.com/tutorial/fastapi/). âš
-Ce tutoriel comprend une section sur <a href="https://sqlmodel.tiangolo.com/tutorial/fastapi/tests/" class="external-link" target="_blank">les tests des bases de donnĂ©es SQL</a>. đ
+Ce tutoriel comprend une section sur les [tests des bases de donnĂ©es SQL](https://sqlmodel.tiangolo.com/tutorial/fastapi/tests/). đ
<em>Framework FastAPI, haute performance, facile Ă apprendre, rapide Ă coder, prĂȘt pour la production</em>
</p>
<p align="center">
-<a href="https://github.com/fastapi/fastapi/actions?query=workflow%3ATest+event%3Apush+branch%3Amaster" target="_blank">
+<a href="https://github.com/fastapi/fastapi/actions?query=workflow%3ATest+event%3Apush+branch%3Amaster">
<img src="https://github.com/fastapi/fastapi/actions/workflows/test.yml/badge.svg?event=push&branch=master" alt="Test">
</a>
-<a href="https://coverage-badge.samuelcolvin.workers.dev/redirect/fastapi/fastapi" target="_blank">
+<a href="https://coverage-badge.samuelcolvin.workers.dev/redirect/fastapi/fastapi">
<img src="https://coverage-badge.samuelcolvin.workers.dev/fastapi/fastapi.svg" alt="Coverage">
</a>
-<a href="https://pypi.org/project/fastapi" target="_blank">
+<a href="https://pypi.org/project/fastapi">
<img src="https://img.shields.io/pypi/v/fastapi?color=%2334D058&label=pypi%20package" alt="Package version">
</a>
-<a href="https://pypi.org/project/fastapi" target="_blank">
+<a href="https://pypi.org/project/fastapi">
<img src="https://img.shields.io/pypi/pyversions/fastapi.svg?color=%2334D058" alt="Supported Python versions">
</a>
</p>
---
-**Documentation** : <a href="https://fastapi.tiangolo.com/fr" target="_blank">https://fastapi.tiangolo.com/fr</a>
+**Documentation** : [https://fastapi.tiangolo.com/fr](https://fastapi.tiangolo.com/fr)
-**Code Source** : <a href="https://github.com/fastapi/fastapi" target="_blank">https://github.com/fastapi/fastapi</a>
+**Code Source** : [https://github.com/fastapi/fastapi](https://github.com/fastapi/fastapi)
---
* **Facile** : conçu pour ĂȘtre facile Ă utiliser et Ă apprendre. Moins de temps passĂ© Ă lire les documents.
* **Concis** : diminue la duplication de code. Plusieurs fonctionnalités à partir de chaque déclaration de paramÚtre. Moins de bugs.
* **Robuste** : obtenez un code prĂȘt pour la production. Avec une documentation interactive automatique.
-* **Basé sur des normes** : basé sur (et entiÚrement compatible avec) les standards ouverts pour les APIs : <a href="https://github.com/OAI/OpenAPI-Specification" class="external-link" target="_blank">OpenAPI</a> (précédemment connu sous le nom de Swagger) et <a href="https://json-schema.org/" class="external-link" target="_blank">JSON Schema</a>.
+* **Basé sur des normes** : basé sur (et entiÚrement compatible avec) les standards ouverts pour les APIs : [OpenAPI](https://github.com/OAI/OpenAPI-Specification) (précédemment connu sous le nom de Swagger) et [JSON Schema](https://json-schema.org/).
<small>* estimation basée sur des tests d'une équipe de développement interne, construisant des applications de production.</small>
### Sponsor clé de voûte { #keystone-sponsor }
{% for sponsor in sponsors.keystone -%}
-<a href="{{ sponsor.url }}" t
arget="_blank" title="{{ sponsor.title }}"><img src="{{ sponsor.img }}" style="border-radius:15px"></a>
+<a href="{{ sponsor.url }}" title="{{ sponsor.title }}"><img src="{{ sponsor.img }}" style="border-radius:15px"></a>
{% endfor -%}
### Sponsors Or et Argent { #gold-and-silver-sponsors }
{% for sponsor in sponsors.gold -%}
-<a href="{{ sponsor.url }}" t
arget="_blank" title="{{ sponsor.title }}"><img src="{{ sponsor.img }}" style="border-radius:15px"></a>
+<a href="{{ sponsor.url }}" title="{{ sponsor.title }}"><img src="{{ sponsor.img }}" style="border-radius:15px"></a>
{% endfor -%}
{%- for sponsor in sponsors.silver -%}
-<a href="{{ sponsor.url }}" t
arget="_blank" title="{{ sponsor.title }}"><img src="{{ sponsor.img }}" style="border-radius:15px"></a>
+<a href="{{ sponsor.url }}" title="{{ sponsor.title }}"><img src="{{ sponsor.img }}" style="border-radius:15px"></a>
{% endfor %}
<!-- /sponsors -->
-<a href="https://fastapi.tiangolo.com/fr/fastapi-people/#sponsors" class="external-link" target="_blank">Autres sponsors</a>
+[Autres sponsors](https://fastapi.tiangolo.com/fr/fastapi-people/#sponsors)
## Opinions { #opinions }
« _[...] J'utilise beaucoup **FastAPI** ces derniers temps. [...] Je prĂ©vois de l'utiliser dans mon Ă©quipe pour tous les **services de ML chez Microsoft**. Certains d'entre eux sont intĂ©grĂ©s au cĆur de **Windows** et Ă certains produits **Office**._ »
-<div style="text-align: right; margin-right: 10%;">Kabir Khan - <strong>Microsoft</strong> <a href="https://github.com/fastapi/fastapi/pull/26" target="_blank"><small>(ref)</small></a></div>
+<div style="text-align: right; margin-right: 10%;">Kabir Khan - <strong>Microsoft</strong> <a href="https://github.com/fastapi/fastapi/pull/26"><small>(ref)</small></a></div>
---
« _Nous avons adoptĂ© la bibliothĂšque **FastAPI** pour crĂ©er un serveur **REST** qui peut ĂȘtre interrogĂ© pour obtenir des **prĂ©dictions**. [pour Ludwig]_ »
-<div style="text-align: right; margin-right: 10%;">Piero Molino, Yaroslav Dudin, et Sai Sumanth Miryala - <strong>Uber</strong> <a href="https://eng.uber.com/ludwig-v0-2/" target="_blank"><small>(ref)</small></a></div>
+<div style="text-align: right; margin-right: 10%;">Piero Molino, Yaroslav Dudin, et Sai Sumanth Miryala - <strong>Uber</strong> <a href="https://eng.uber.com/ludwig-v0-2/"><small>(ref)</small></a></div>
---
« _**Netflix** est heureux d'annoncer la publication en open source de notre framework d'orchestration de **gestion de crise** : **Dispatch** ! [construit avec **FastAPI**]_ »
-<div style="text-align: right; margin-right: 10%;">Kevin Glisson, Marc Vilanova, Forest Monsen - <strong>Netflix</strong> <a href="https://netflixtechblog.com/introducing-dispatch-da4b8a2a8072" target="_blank"><small>(ref)</small></a></div>
+<div style="text-align: right; margin-right: 10%;">Kevin Glisson, Marc Vilanova, Forest Monsen - <strong>Netflix</strong> <a href="https://netflixtechblog.com/introducing-dispatch-da4b8a2a8072"><small>(ref)</small></a></div>
---
« _Je suis plus qu'enthousiaste à propos de **FastAPI**. C'est tellement fun !_ »
-<div style="text-align: right; margin-right: 10%;">Brian Okken - <strong>Animateur du podcast <a href="https://pythonbytes.fm/episodes/show/123/time-to-right-the-py-wrongs?time_in_sec=855" target="_blank">Python Bytes</a></strong> <a href="https://x.com/brianokken/status/1112220079972728832" target="_blank"><small>(ref)</small></a></div>
+<div style="text-align: right; margin-right: 10%;">Brian Okken - <strong>Animateur du podcast [Python Bytes](https://pythonbytes.fm/episodes/show/123/time-to-right-the-py-wrongs?time_in_sec=855)</strong> <a href="https://x.com/brianokken/status/1112220079972728832"><small>(ref)</small></a></div>
---
« _HonnĂȘtement, ce que vous avez construit a l'air super solide et soignĂ©. Ă bien des Ă©gards, c'est ce que je voulais que **Hug** soit â c'est vraiment inspirant de voir quelqu'un construire ça._ »
-<div style="text-align: right; margin-right: 10%;">Timothy Crosley - <strong>Créateur de <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>Créateur de [Hug](https://github.com/hugapi/hug)</strong> <a href="https://news.ycombinator.com/item?id=19455465"><small>(ref)</small></a></div>
---
« _Nous sommes passés à **FastAPI** pour nos **APIs** [...] Je pense que vous l'aimerez [...]_ »
-<div style="text-align: right; margin-right: 10%;">Ines Montani - Matthew Honnibal - <strong>Fondateurs de <a href="https://explosion.ai" target="_blank">Explosion AI</a> - Créateurs de <a href="https://spacy.io" target="_blank">spaCy</a></strong> <a href="https://x.com/_inesmontani/status/1144173225322143744" target="_blank"><small>(ref)</small></a> - <a href="https://x.com/honnibal/status/1144031421859655680" target="_blank"><small>(ref)</small></a></div>
+<div style="text-align: right; margin-right: 10%;">Ines Montani - Matthew Honnibal - <strong>Fondateurs de [Explosion AI](https://explosion.ai) - Créateurs de [spaCy](https://spacy.io)</strong> <a href="https://x.com/_inesmontani/status/1144173225322143744"><small>(ref)</small></a> - <a href="https://x.com/honnibal/status/1144031421859655680"><small>(ref)</small></a></div>
---
« _Si quelqu'un cherche à construire une API Python de production, je recommande vivement **FastAPI**. Il est **magnifiquement conçu**, **simple à utiliser** et **hautement scalable**. Il est devenu un **composant clé** de notre stratégie de développement API-first et alimente de nombreuses automatisations et services tels que notre ingénieur TAC virtuel._ »
-<div style="text-align: right; margin-right: 10%;">Deon Pillsbury - <strong>Cisco</strong> <a href="https://www.linkedin.com/posts/deonpillsbury_cisco-cx-python-activity-6963242628536487936-trAp/" target="_blank"><small>(ref)</small></a></div>
+<div style="text-align: right; margin-right: 10%;">Deon Pillsbury - <strong>Cisco</strong> <a href="https://www.linkedin.com/posts/deonpillsbury_cisco-cx-python-activity-6963242628536487936-trAp/"><small>(ref)</small></a></div>
---
## Mini documentaire FastAPI { #fastapi-mini-documentary }
-Un <a href="https://www.youtube.com/watch?v=mpR8ngthqiE" class="external-link" target="_blank">mini documentaire FastAPI</a> est sorti fin 2025, vous pouvez le regarder en ligne :
+Un [mini documentaire FastAPI](https://www.youtube.com/watch?v=mpR8ngthqiE) est sorti fin 2025, vous pouvez le regarder en ligne :
-<a href="https://www.youtube.com/watch?v=mpR8ngthqiE"
target="_blank"><img src="https://fastapi.tiangolo.com/img/fastapi-documentary.jpg" alt="FastAPI Mini Documentary"></a>
+<a href="https://www.youtube.com/watch?v=mpR8ngthqiE"><img src="https://fastapi.tiangolo.com/img/fastapi-documentary.jpg" alt="FastAPI Mini Documentary"></a>
## **Typer**, le FastAPI des 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>
+<a href="https://typer.tiangolo.com"><img src="https://typer.tiangolo.com/img/logo-margin/logo-margin-vector.svg" style="width: 20%;"></a>
-Si vous construisez une application <abbr title="Command Line Interface - Interface en ligne de commande">CLI</abbr> Ă utiliser dans un terminal au lieu d'une API web, regardez <a href="https://typer.tiangolo.com/" class="external-link" target="_blank">**Typer**</a>.
+Si vous construisez une application <abbr title="Command Line Interface - Interface en ligne de commande">CLI</abbr> Ă utiliser dans un terminal au lieu d'une API web, regardez [**Typer**](https://typer.tiangolo.com/).
**Typer** est le petit frĂšre de FastAPI. Et il est destinĂ© Ă ĂȘtre le **FastAPI des CLIs**. âšïž đ
FastAPI repose sur les épaules de géants :
-* <a href="https://www.starlette.dev/" class="external-link" target="_blank">Starlette</a> pour les parties web.
-* <a href="https://docs.pydantic.dev/" class="external-link" target="_blank">Pydantic</a> pour les parties données.
+* [Starlette](https://www.starlette.dev/) pour les parties web.
+* [Pydantic](https://docs.pydantic.dev/) pour les parties données.
## Installation { #installation }
-Créez et activez un <a href="https://fastapi.tiangolo.com/fr/virtual-environments/" class="external-link" target="_blank">environnement virtuel</a> puis installez FastAPI :
+Créez et activez un [environnement virtuel](https://fastapi.tiangolo.com/fr/virtual-environments/) puis installez FastAPI :
<div class="termy">
**Remarque** :
-Si vous ne savez pas, consultez la section « Vous ĂȘtes pressĂ©s ? » Ă propos de <a href="https://fastapi.tiangolo.com/fr/async/#in-a-hurry" target="_blank">`async` et `await` dans la documentation</a>.
+Si vous ne savez pas, consultez la section « Vous ĂȘtes pressĂ©s ? » Ă propos de [`async` et `await` dans la documentation](https://fastapi.tiangolo.com/fr/async/#in-a-hurry).
</details>
<div class="termy">
```console
-$ fastapi dev main.py
+$ fastapi dev
âââââââââââ FastAPI CLI - Development mode ââââââââââââź
â â
</div>
<details markdown="1">
-<summary>Ă propos de la commande <code>fastapi dev main.py</code>...</summary>
+<summary>Ă propos de la commande <code>fastapi dev</code>...</summary>
-La commande `fastapi dev` lit votre fichier `main.py`, détecte l'application **FastAPI** qu'il contient et lance un serveur avec <a href="https://www.uvicorn.dev" class="external-link" target="_blank">Uvicorn</a>.
+La commande `fastapi dev` lit automatiquement votre fichier `main.py`, détecte l'application **FastAPI** qu'il contient et lance un serveur avec [Uvicorn](https://www.uvicorn.dev).
Par défaut, `fastapi dev` démarre avec le rechargement automatique activé pour le développement local.
-Vous pouvez en savoir plus dans la <a href="https://fastapi.tiangolo.com/fr/fastapi-cli/" target="_blank">documentation de la CLI FastAPI</a>.
+Vous pouvez en savoir plus dans la [documentation de la CLI FastAPI](https://fastapi.tiangolo.com/fr/fastapi-cli/).
</details>
### VĂ©rifier { #check-it }
-Ouvrez votre navigateur Ă l'adresse <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>.
+Ouvrez votre navigateur Ă l'adresse [http://127.0.0.1:8000/items/5?q=somequery](http://127.0.0.1:8000/items/5?q=somequery).
Vous verrez la réponse JSON :
### Documentation API interactive { #interactive-api-docs }
-Maintenant, rendez-vous sur <a href="http://127.0.0.1:8000/docs" class="external-link" target="_blank">http://127.0.0.1:8000/docs</a>.
+Maintenant, rendez-vous sur [http://127.0.0.1:8000/docs](http://127.0.0.1:8000/docs).
-Vous verrez la documentation interactive automatique de l'API (fournie par <a href="https://github.com/swagger-api/swagger-ui" class="external-link" target="_blank">Swagger UI</a>) :
+Vous verrez la documentation interactive automatique de l'API (fournie par [Swagger UI](https://github.com/swagger-api/swagger-ui)) :
### Documentation API alternative { #alternative-api-docs }
-Et maintenant, rendez-vous sur <a href="http://127.0.0.1:8000/redoc" class="external-link" target="_blank">http://127.0.0.1:8000/redoc</a>.
+Et maintenant, rendez-vous sur [http://127.0.0.1:8000/redoc](http://127.0.0.1:8000/redoc).
-Vous verrez la documentation alternative automatique (fournie par <a href="https://github.com/Rebilly/ReDoc" class="external-link" target="_blank">ReDoc</a>) :
+Vous verrez la documentation alternative automatique (fournie par [ReDoc](https://github.com/Rebilly/ReDoc)) :
### Mettre Ă niveau la documentation API interactive { #interactive-api-docs-upgrade }
-Maintenant, rendez-vous sur <a href="http://127.0.0.1:8000/docs" class="external-link" target="_blank">http://127.0.0.1:8000/docs</a>.
+Maintenant, rendez-vous sur [http://127.0.0.1:8000/docs](http://127.0.0.1:8000/docs).
* La documentation interactive de l'API sera automatiquement mise Ă jour, y compris le nouveau corps :
### Mettre Ă niveau la documentation API alternative { #alternative-api-docs-upgrade }
-Et maintenant, rendez-vous sur <a href="http://127.0.0.1:8000/redoc" class="external-link" target="_blank">http://127.0.0.1:8000/redoc</a>.
+Et maintenant, rendez-vous sur [http://127.0.0.1:8000/redoc](http://127.0.0.1:8000/redoc).
* La documentation alternative reflĂštera Ă©galement le nouveau paramĂštre de requĂȘte et le nouveau corps :
* Un systÚme **<dfn title="également connu sous le nom de : composants, ressources, fournisseurs, services, injectables">d'injection de dépendances</dfn>** trÚs puissant et facile à utiliser.
* Sécurité et authentification, y compris la prise en charge de **OAuth2** avec des **JWT tokens** et l'authentification **HTTP Basic**.
* Des techniques plus avancées (mais tout aussi faciles) pour déclarer des **modÚles JSON profondément imbriqués** (grùce à Pydantic).
-* Intégration **GraphQL** avec <a href="https://strawberry.rocks" class="external-link" target="_blank">Strawberry</a> et d'autres bibliothÚques.
+* Intégration **GraphQL** avec [Strawberry](https://strawberry.rocks) et d'autres bibliothÚques.
* De nombreuses fonctionnalités supplémentaires (grùce à Starlette) comme :
* **WebSockets**
* des tests extrĂȘmement faciles basĂ©s sur HTTPX et `pytest`
### DĂ©ployer votre application (optionnel) { #deploy-your-app-optional }
-Vous pouvez, si vous le souhaitez, dĂ©ployer votre application FastAPI sur <a href="https://fastapicloud.com" class="external-link" target="_blank">FastAPI Cloud</a>, allez vous inscrire sur la liste d'attente si ce n'est pas dĂ©jĂ fait. đ
+Vous pouvez, si vous le souhaitez, dĂ©ployer votre application FastAPI sur [FastAPI Cloud](https://fastapicloud.com), allez vous inscrire sur la liste d'attente si ce n'est pas dĂ©jĂ fait. đ
Si vous avez dĂ©jĂ un compte **FastAPI Cloud** (nous vous avons invitĂ© depuis la liste d'attente đ), vous pouvez dĂ©ployer votre application avec une seule commande.
-Avant de dĂ©ployer, assurez-vous d'ĂȘtre connectĂ© :
-
-<div class="termy">
-
-```console
-$ fastapi login
-
-You are logged in to FastAPI Cloud đ
-```
-
-</div>
-
-Puis déployez votre application :
-
<div class="termy">
```console
#### Ă propos de FastAPI Cloud { #about-fastapi-cloud }
-**<a href="https://fastapicloud.com" class="external-link" target="_blank">FastAPI Cloud</a>** est construit par le mĂȘme auteur et la mĂȘme Ă©quipe derriĂšre **FastAPI**.
+**[FastAPI Cloud](https://fastapicloud.com)** est construit par le mĂȘme auteur et la mĂȘme Ă©quipe derriĂšre **FastAPI**.
Il simplifie le processus de **construction**, de **déploiement** et **d'accÚs** à une API avec un effort minimal.
## Performance { #performance }
-Les benchmarks TechEmpower indĂ©pendants montrent que les applications **FastAPI** s'exĂ©cutant sous Uvicorn sont <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">parmi les frameworks Python les plus rapides</a>, juste derriĂšre Starlette et Uvicorn eux-mĂȘmes (utilisĂ©s en interne par FastAPI). (*)
+Les benchmarks TechEmpower indĂ©pendants montrent que les applications **FastAPI** s'exĂ©cutant sous Uvicorn sont [parmi les frameworks Python les plus rapides](https://www.techempower.com/benchmarks/#section=test&runid=7464e520-0dc2-473d-bd34-dbdfd7e85911&hw=ph&test=query&l=zijzen-7), juste derriĂšre Starlette et Uvicorn eux-mĂȘmes (utilisĂ©s en interne par FastAPI). (*)
-Pour en savoir plus, consultez la section <a href="https://fastapi.tiangolo.com/fr/benchmarks/" class="internal-link" target="_blank">Benchmarks</a>.
+Pour en savoir plus, consultez la section [Benchmarks](https://fastapi.tiangolo.com/fr/benchmarks/).
## DĂ©pendances { #dependencies }
Utilisées par Pydantic :
-* <a href="https://github.com/JoshData/python-email-validator" target="_blank"><code>email-validator</code></a> - pour la validation des adresses e-mail.
+* [`email-validator`](https://github.com/JoshData/python-email-validator) - pour la validation des adresses e-mail.
Utilisées par Starlette :
-* <a href="https://www.python-httpx.org" target="_blank"><code>httpx</code></a> - Obligatoire si vous souhaitez utiliser le `TestClient`.
-* <a href="https://jinja.palletsprojects.com" target="_blank"><code>jinja2</code></a> - Obligatoire si vous souhaitez utiliser la configuration de template par défaut.
-* <a href="https://github.com/Kludex/python-multipart" target="_blank"><code>python-multipart</code></a> - 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()`.
+* [`httpx`](https://www.python-httpx.org) - Obligatoire si vous souhaitez utiliser le `TestClient`.
+* [`jinja2`](https://jinja.palletsprojects.com) - Obligatoire si vous souhaitez utiliser la configuration de template par défaut.
+* [`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 :
-* <a href="https://www.uvicorn.dev" target="_blank"><code>uvicorn</code></a> - pour le serveur qui charge et sert votre application. Cela inclut `uvicorn[standard]`, qui comprend certaines dépendances (par ex. `uvloop`) nécessaires pour une haute performance.
+* [`uvicorn`](https://www.uvicorn.dev) - pour le serveur qui charge et sert votre application. Cela inclut `uvicorn[standard]`, qui comprend certaines dépendances (par ex. `uvloop`) nécessaires pour une haute performance.
* `fastapi-cli[standard]` - pour fournir la commande `fastapi`.
- * Cela inclut `fastapi-cloud-cli`, qui vous permet de déployer votre application FastAPI sur <a href="https://fastapicloud.com" class="external-link" target="_blank">FastAPI Cloud</a>.
+ * Cela inclut `fastapi-cloud-cli`, qui vous permet de déployer votre application FastAPI sur [FastAPI Cloud](https://fastapicloud.com).
### Sans les dépendances `standard` { #without-standard-dependencies }
Dépendances optionnelles supplémentaires pour Pydantic :
-* <a href="https://docs.pydantic.dev/latest/usage/pydantic_settings/" target="_blank"><code>pydantic-settings</code></a> - pour la gestion des paramĂštres.
-* <a href="https://docs.pydantic.dev/latest/usage/types/extra_types/extra_types/" target="_blank"><code>pydantic-extra-types</code></a> - pour des types supplémentaires à utiliser avec Pydantic.
+* [`pydantic-settings`](https://docs.pydantic.dev/latest/usage/pydantic_settings/) - pour la gestion des paramĂštres.
+* [`pydantic-extra-types`](https://docs.pydantic.dev/latest/usage/types/extra_types/extra_types/) - pour des types supplémentaires à utiliser avec Pydantic.
Dépendances optionnelles supplémentaires pour FastAPI :
-* <a href="https://github.com/ijl/orjson" target="_blank"><code>orjson</code></a> - Obligatoire si vous souhaitez utiliser `ORJSONResponse`.
-* <a href="https://github.com/esnme/ultrajson" target="_blank"><code>ujson</code></a> - Obligatoire si vous souhaitez utiliser `UJSONResponse`.
+* [`orjson`](https://github.com/ijl/orjson) - Obligatoire si vous souhaitez utiliser `ORJSONResponse`.
+* [`ujson`](https://github.com/esnme/ultrajson) - Obligatoire si vous souhaitez utiliser `UJSONResponse`.
## Licence { #license }
Vous pouvez utiliser ce modĂšle pour dĂ©marrer, car il inclut une grande partie de la configuration initiale, la sĂ©curitĂ©, la base de donnĂ©es et quelques endpoints d'API dĂ©jĂ prĂȘts pour vous.
-DĂ©pĂŽt GitHub : <a href="https://github.com/tiangolo/full-stack-fastapi-template" class="external-link" target="_blank">ModĂšle Full Stack FastAPI</a>
+DĂ©pĂŽt GitHub : [ModĂšle Full Stack FastAPI](https://github.com/tiangolo/full-stack-fastapi-template)
## ModÚle Full Stack FastAPI - Pile technologique et fonctionnalités { #full-stack-fastapi-template-technology-stack-and-features }
{* ../../docs_src/python_types/tutorial006_py310.py hl[1] *}
-/// info | Info
+/// info
Ces types internes entre crochets sont appelés « paramÚtres de type ».
## ModĂšles Pydantic { #pydantic-models }
-<a href="https://docs.pydantic.dev/" class="external-link" target="_blank">Pydantic</a> est une bibliothÚque Python pour effectuer de la validation de données.
+[Pydantic](https://docs.pydantic.dev/) est une bibliothÚque Python pour effectuer de la validation de données.
Vous déclarez la « forme » de la donnée sous forme de classes avec des attributs.
{* ../../docs_src/python_types/tutorial011_py310.py *}
-/// info | Info
+/// info
-Pour en savoir plus Ă propos de <a href="https://docs.pydantic.dev/" class="external-link" target="_blank">Pydantic, consultez sa documentation</a>.
+Pour en savoir plus Ă propos de [Pydantic, consultez sa documentation](https://docs.pydantic.dev/).
///
**FastAPI** est entiÚrement basé sur Pydantic.
-Vous verrez beaucoup plus de tout cela en pratique dans le [Tutoriel - Guide utilisateur](tutorial/index.md){.internal-link target=_blank}.
+Vous verrez beaucoup plus de tout cela en pratique dans le [Tutoriel - Guide utilisateur](tutorial/index.md).
## Annotations de type avec métadonnées { #type-hints-with-metadata-annotations }
* **Documenter** l'API avec OpenAPI :
* ce qui est ensuite utilisé par les interfaces utilisateur de documentation interactive automatiques.
-Tout cela peut sembler abstrait. Ne vous inquiétez pas. Vous verrez tout cela en action dans le [Tutoriel - Guide utilisateur](tutorial/index.md){.internal-link target=_blank}.
+Tout cela peut sembler abstrait. Ne vous inquiétez pas. Vous verrez tout cela en action dans le [Tutoriel - Guide utilisateur](tutorial/index.md).
L'important est qu'en utilisant les types standards de Python, en un seul endroit (au lieu d'ajouter plus de classes, de décorateurs, etc.), **FastAPI** fera une grande partie du travail pour vous.
-/// info | Info
+/// info
-Si vous avez dĂ©jĂ parcouru tout le tutoriel et ĂȘtes revenu pour en voir plus sur les types, une bonne ressource est <a href="https://mypy.readthedocs.io/en/latest/cheat_sheet_py3.html" class="external-link" target="_blank">l'« aide-mĂ©moire » de `mypy`</a>.
+Si vous avez dĂ©jĂ parcouru tout le tutoriel et ĂȘtes revenu pour en voir plus sur les types, une bonne ressource est [l'« aide-mĂ©moire » de `mypy`](https://mypy.readthedocs.io/en/latest/cheat_sheet_py3.html).
///
## DĂ©tails techniques { #technical-details }
-La classe `BackgroundTasks` provient directement de <a href="https://www.starlette.dev/background/" class="external-link" target="_blank">`starlette.background`</a>.
+La classe `BackgroundTasks` provient directement de [`starlette.background`](https://www.starlette.dev/background/).
Elle est importée/incluse directement dans **FastAPI** pour que vous puissiez l'importer depuis `fastapi` et éviter d'importer accidentellement `BackgroundTask` (sans `s` à la fin) depuis `starlette.background`.
Il est tout de mĂȘme possible d'utiliser `BackgroundTask` seul dans **FastAPI**, mais dans ce cas il faut crĂ©er l'objet dans le code et renvoyer une `Response` Starlette l'incluant.
-Plus de détails sont disponibles dans <a href="https://www.starlette.dev/background/" class="external-link" target="_blank">la documentation officielle de Starlette sur les tùches d'arriÚre-plan</a>.
+Plus de détails sont disponibles dans [la documentation officielle de Starlette sur les tùches d'arriÚre-plan](https://www.starlette.dev/background/).
## Avertissement { #caveat }
-Si vous avez besoin de rĂ©aliser des traitements lourds en tĂąche d'arriĂšre-plan et que vous n'avez pas besoin que ces traitements aient lieu dans le mĂȘme process (par exemple, pas besoin de partager la mĂ©moire, les variables, etc.), il peut s'avĂ©rer profitable d'utiliser des outils plus importants tels que <a href="https://docs.celeryq.dev" class="external-link" target="_blank">Celery</a>.
+Si vous avez besoin de rĂ©aliser des traitements lourds en tĂąche d'arriĂšre-plan et que vous n'avez pas besoin que ces traitements aient lieu dans le mĂȘme process (par exemple, pas besoin de partager la mĂ©moire, les variables, etc.), il peut s'avĂ©rer profitable d'utiliser des outils plus importants tels que [Celery](https://docs.celeryq.dev).
Ces outils nécessitent généralement des configurations plus complexes ainsi qu'un gestionnaire de queue de message, comme RabbitMQ ou Redis, mais ils permettent d'exécuter des tùches d'arriÚre-plan dans différents process, et surtout, sur plusieurs serveurs.
Nous utilisons un en-tĂȘte inventĂ© pour simplifier cet exemple.
-Mais dans les cas réels, vous obtiendrez de meilleurs résultats en utilisant les [utilitaires de sécurité](security/index.md){.internal-link target=_blank} intégrés.
+Mais dans les cas réels, vous obtiendrez de meilleurs résultats en utilisant les [utilitaires de sécurité](security/index.md) intégrés.
///
/// tip | Astuce
-Notez que, tout comme pour les [dépendances dans les décorateurs de *chemin d'accÚs*](dependencies/dependencies-in-path-operation-decorators.md){.internal-link target=_blank}, aucune valeur ne sera transmise à votre *fonction de chemin d'accÚs*.
+Notez que, tout comme pour les [dépendances dans les décorateurs de *chemin d'accÚs*](dependencies/dependencies-in-path-operation-decorators.md), aucune valeur ne sera transmise à votre *fonction de chemin d'accÚs*.
///
* Ils incluront tous les `responses` prédéfinies.
* Tous ces *chemins d'accÚs* auront la liste des `dependencies` évaluées/exécutées avant eux.
* Si vous déclarez également des dépendances dans un *chemin d'accÚs* spécifique, **elles seront aussi exécutées**.
- * Les dépendances du routeur sont exécutées en premier, puis les [`dependencies` dans le décorateur](dependencies/dependencies-in-path-operation-decorators.md){.internal-link target=_blank}, puis les dépendances des paramÚtres normaux.
- * Vous pouvez Ă©galement ajouter des [`Security` dependencies avec des `scopes`](../advanced/security/oauth2-scopes.md){.internal-link target=_blank}.
+ * Les dépendances du routeur sont exécutées en premier, puis les [`dependencies` dans le décorateur](dependencies/dependencies-in-path-operation-decorators.md), puis les dépendances des paramÚtres normaux.
+ * Vous pouvez Ă©galement ajouter des [`Security` dependencies avec des `scopes`](../advanced/security/oauth2-scopes.md).
/// tip | Astuce
Vous importez et créez une classe `FastAPI` comme d'habitude.
-Et nous pouvons mĂȘme dĂ©clarer des [dĂ©pendances globales](dependencies/global-dependencies.md){.internal-link target=_blank} qui seront combinĂ©es avec les dĂ©pendances de chaque `APIRouter` :
+Et nous pouvons mĂȘme dĂ©clarer des [dĂ©pendances globales](dependencies/global-dependencies.md) qui seront combinĂ©es avec les dĂ©pendances de chaque `APIRouter` :
{* ../../docs_src/bigger_applications/app_an_py310/main.py hl[1,3,7] title["app/main.py"] *}
from app.routers import items, users
```
-Pour en savoir plus sur les Packages et Modules Python, lisez <a href="https://docs.python.org/3/tutorial/modules.html" class="external-link" target="_blank">la documentation officielle de Python sur les modules</a>.
+Pour en savoir plus sur les Packages et Modules Python, lisez [la documentation officielle de Python sur les modules](https://docs.python.org/3/tutorial/modules.html).
///
Nous pouvons Ă©galement ajouter des *chemins d'accĂšs* directement Ă l'application `FastAPI`.
-Ici, nous le faisons... juste pour montrer que nous le pouvons đ€· :
+Ici, nous le faisons ... juste pour montrer que nous le pouvons đ€· :
{* ../../docs_src/bigger_applications/app_an_py310/main.py hl[21:23] title["app/main.py"] *}
///
+## Configurer l'`entrypoint` dans `pyproject.toml` { #configure-the-entrypoint-in-pyproject-toml }
+
+Comme votre objet FastAPI `app` vit dans `app/main.py`, vous pouvez configurer l'`entrypoint` dans votre fichier `pyproject.toml` comme ceci :
+
+```toml
+[tool.fastapi]
+entrypoint = "app.main:app"
+```
+
+ce qui Ă©quivaut Ă importer ainsi :
+
+```python
+from app.main import app
+```
+
+De cette façon, la commande `fastapi` saura oĂč trouver votre app.
+
+/// Note | Remarque
+
+Vous pourriez aussi passer le chemin Ă la commande, comme :
+
+```console
+$ fastapi dev app/main.py
+```
+
+Mais vous devriez vous rappeler de passer le bon chemin Ă chaque fois que vous appelez la commande `fastapi`.
+
+En outre, d'autres outils pourraient ne pas ĂȘtre en mesure de la trouver, par exemple l'[Extension VS Code](../editor-support.md) ou [FastAPI Cloud](https://fastapicloud.com), il est donc recommandĂ© d'utiliser l'`entrypoint` dans `pyproject.toml`.
+
+///
+
## Consulter la documentation API automatique { #check-the-automatic-api-docs }
Maintenant, exécutez votre application :
<div class="termy">
```console
-$ fastapi dev app/main.py
+$ fastapi dev
<span style="color: green;">INFO</span>: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
```
</div>
-Et ouvrez les documents Ă <a href="http://127.0.0.1:8000/docs" class="external-link" target="_blank">http://127.0.0.1:8000/docs</a>.
+Et ouvrez les documents Ă [http://127.0.0.1:8000/docs](http://127.0.0.1:8000/docs).
Vous verrez la documentation API automatique, incluant les chemins de tous les sous-modules, utilisant les bons chemins (et préfixes) et les bons tags :
Outre les types singuliers normaux comme `str`, `int`, `float`, etc. vous pouvez utiliser des types singuliers plus complexes qui héritent de `str`.
-Pour voir toutes les options dont vous disposez, consultez <a href="https://docs.pydantic.dev/latest/concepts/types/" class="external-link" target="_blank">lâaperçu des types de Pydantic</a>. Vous verrez quelques exemples au chapitre suivant.
+Pour voir toutes les options dont vous disposez, consultez [lâaperçu des types de Pydantic](https://docs.pydantic.dev/latest/concepts/types/). Vous verrez quelques exemples au chapitre suivant.
Par exemple, comme dans le modÚle `Image` nous avons un champ `url`, nous pouvons le déclarer comme instance de `HttpUrl` de Pydantic au lieu de `str` :
## Mettre à jour en remplaçant avec `PUT` { #update-replacing-with-put }
-Pour mettre Ă jour un Ă©lĂ©ment, vous pouvez utiliser lâopĂ©ration <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/PUT" class="external-link" target="_blank">HTTP `PUT`</a>.
+Pour mettre Ă jour un Ă©lĂ©ment, vous pouvez utiliser lâopĂ©ration [HTTP `PUT`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/PUT).
Vous pouvez utiliser le `jsonable_encoder` pour convertir les donnĂ©es dâentrĂ©e en donnĂ©es pouvant ĂȘtre stockĂ©es au format JSON (par exemple, avec une base de donnĂ©es NoSQL). Par exemple, convertir `datetime` en `str`.
comme il nâinclut pas lâattribut dĂ©jĂ enregistrĂ© « tax »: 20.2, le modĂšle dâentrĂ©e prendrait la valeur par dĂ©faut « tax »: 10.5.
-Et les données seraient enregistrées avec cette « nouvelle » `tax` de `10.5`.
+Et les données seraient enregistrées avec cette « nouvelle » « tax » de 10.5.
## Effectuer des mises Ă jour partielles avec `PATCH` { #partial-updates-with-patch }
-Vous pouvez Ă©galement utiliser lâopĂ©ration <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/PATCH" class="external-link" target="_blank">HTTP `PATCH`</a> pour mettre Ă jour des donnĂ©es de maniĂšre partielle.
+Vous pouvez Ă©galement utiliser lâopĂ©ration [HTTP `PATCH`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/PATCH) pour mettre Ă jour des donnĂ©es de maniĂšre partielle.
Cela signifie que vous pouvez nâenvoyer que les donnĂ©es que vous souhaitez mettre Ă jour, en laissant le reste intact.
Ainsi, si vous souhaitez recevoir des mises Ă jour partielles pouvant omettre tous les attributs, vous devez disposer dâun modĂšle avec tous les attributs marquĂ©s comme optionnels (avec des valeurs par dĂ©faut ou `None`).
-Pour distinguer les modÚles avec toutes les valeurs optionnelles pour les mises à jour et les modÚles avec des valeurs requises pour la création, vous pouvez utiliser les idées décrites dans [ModÚles supplémentaires](extra-models.md){.internal-link target=_blank}.
+Pour distinguer les modÚles avec toutes les valeurs optionnelles pour les mises à jour et les modÚles avec des valeurs requises pour la création, vous pouvez utiliser les idées décrites dans [ModÚles supplémentaires](extra-models.md).
///
Le corps d'une **requĂȘte** est de la donnĂ©e envoyĂ©e par le client Ă votre API. Le corps d'une **rĂ©ponse** est la donnĂ©e envoyĂ©e par votre API au client.
-Votre API aura presque toujours Ă envoyer un corps de **rĂ©ponse**. Mais un client n'a pas toujours Ă envoyer un **corps de requĂȘte** : parfois il demande seulement un chemin, peut-ĂȘtre avec quelques paramĂštres de requĂȘte, mais n'envoie pas de corps.
+Votre API aura presque toujours Ă envoyer un corps de **rĂ©ponse**. Mais un client n'a pas toujours Ă envoyer un **corps de requĂȘte** : parfois il demande seulement un chemin, peut-ĂȘtre avec quelques paramĂštres de requĂȘte, mais n'envoie pas de corps.
-Pour dĂ©clarer un corps de **requĂȘte**, on utilise les modĂšles de <a href="https://docs.pydantic.dev/" class="external-link" target="_blank">Pydantic</a> en profitant de tous leurs avantages et fonctionnalitĂ©s.
+Pour dĂ©clarer un corps de **requĂȘte**, on utilise les modĂšles de [Pydantic](https://docs.pydantic.dev/) en profitant de tous leurs avantages et fonctionnalitĂ©s.
/// info
{* ../../docs_src/body/tutorial001_py310.py hl[5:9] *}
-Tout comme pour la dĂ©claration de paramĂštres de requĂȘte, quand un attribut de modĂšle a une valeur par dĂ©faut, il n'est pas nĂ©cessaire. Sinon, cet attribut doit ĂȘtre renseignĂ© dans le corps de la requĂȘte. Utilisez `None` pour le rendre simplement optionnel.
+Tout comme pour la dĂ©claration de paramĂštres de requĂȘte, quand un attribut de modĂšle a une valeur par dĂ©faut, il n'est pas nĂ©cessaire. Sinon, il est requis. Utilisez `None` pour le rendre simplement optionnel.
-Par exemple, le modÚle ci-dessus déclare un JSON « `object` » (ou `dict` Python) tel que :
+Par exemple, le modÚle ci-dessus déclare un JSON « `object` » (ou `dict` Python) tel que :
```JSON
{
}
```
-... `description` et `tax` étant des attributs optionnels (avec `None` comme valeur par défaut), ce JSON « `object` » serait aussi valide :
+... `description` et `tax` étant des attributs optionnels (avec `None` comme valeur par défaut), ce JSON « `object` » serait aussi valide :
```JSON
{
{* ../../docs_src/body/tutorial001_py310.py hl[16] *}
-... et déclarez que son type est le modÚle que vous avez créé : `Item`.
+... et déclarez que son type est le modÚle que vous avez créé : `Item`.
## RĂ©sultats { #results }
* Si la donnĂ©e est invalide, une erreur propre et claire sera renvoyĂ©e, indiquant exactement oĂč et quelle Ă©tait la donnĂ©e incorrecte.
* Passer la donnée reçue dans le paramÚtre `item`.
* Ce paramÚtre ayant été déclaré dans la fonction comme étant de type `Item`, vous aurez aussi tout le support offert par l'éditeur (autocomplétion, etc.) pour tous les attributs de ce paramÚtre et les types de ces attributs.
-* Générer des définitions <a href="https://json-schema.org" class="external-link" target="_blank">JSON Schema</a> pour votre modÚle ; vous pouvez également les utiliser partout ailleurs si cela a du sens pour votre projet.
+* Générer des définitions [JSON Schema](https://json-schema.org) pour votre modÚle ; vous pouvez également les utiliser partout ailleurs si cela a du sens pour votre projet.
* Ces schémas participeront à la constitution du schéma généré OpenAPI, et seront utilisés par les documentations automatiques <abbr title="User Interfaces - Interfaces utilisateur">UIs</abbr>.
## Documentation automatique { #automatic-docs }
Des changements sur Pydantic ont mĂȘme Ă©tĂ© faits pour supporter cela.
-Les captures d'écran précédentes ont été prises sur <a href="https://code.visualstudio.com" class="external-link" target="_blank">Visual Studio Code</a>.
+Les captures d'écran précédentes ont été prises sur [Visual Studio Code](https://code.visualstudio.com).
-Mais vous auriez le mĂȘme support de l'Ă©diteur avec <a href="https://www.jetbrains.com/pycharm/" class="external-link" target="_blank">PyCharm</a> et la majoritĂ© des autres Ă©diteurs de code Python :
+Mais vous auriez le mĂȘme support de l'Ă©diteur avec [PyCharm](https://www.jetbrains.com/pycharm/) et la majoritĂ© des autres Ă©diteurs de code Python :
<img src="/img/tutorial/body/image05.png">
/// tip | Astuce
-Si vous utilisez <a href="https://www.jetbrains.com/pycharm/" class="external-link" target="_blank">PyCharm</a> comme Ă©diteur, vous pouvez utiliser le plug-in <a href="https://github.com/koxudaxi/pydantic-pycharm-plugin/" class="external-link" target="_blank">Pydantic PyCharm Plugin</a>.
+Si vous utilisez [PyCharm](https://www.jetbrains.com/pycharm/) comme Ă©diteur, vous pouvez utiliser le plug-in [Pydantic PyCharm Plugin](https://github.com/koxudaxi/pydantic-pycharm-plugin/).
Ce qui améliore le support pour les modÚles Pydantic avec :
* de l'autocomplétion
* des vérifications de type
-* du « refactoring »
+* du « refactoring »
* de la recherche
* des inspections
## Sans Pydantic { #without-pydantic }
-Si vous ne voulez pas utiliser des modĂšles Pydantic, vous pouvez aussi utiliser des paramĂštres de **Body**. Pour cela, allez voir la documentation sur [Corps de la requĂȘte - ParamĂštres multiples : Valeurs singuliĂšres dans le corps](body-multiple-params.md#singular-values-in-body){.internal-link target=_blank}.
+Si vous ne voulez pas utiliser des modĂšles Pydantic, vous pouvez aussi utiliser des paramĂštres de **Body**. Pour cela, allez voir la documentation sur [Corps de la requĂȘte - ParamĂštres multiples : Valeurs singuliĂšres dans le corps](body-multiple-params.md#singular-values-in-body).
# CORS (Partage des ressources entre origines) { #cors-cross-origin-resource-sharing }
-<a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS" class="external-link" target="_blank">CORS ou « Cross-Origin Resource Sharing »</a> fait rĂ©fĂ©rence aux situations oĂč un frontend exĂ©cutĂ© dans un navigateur contient du code JavaScript qui communique avec un backend, et oĂč le backend se trouve dans une « origine » diffĂ©rente de celle du frontend.
+[CORS ou « Cross-Origin Resource Sharing »](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS) fait rĂ©fĂ©rence aux situations oĂč un frontend exĂ©cutĂ© dans un navigateur contient du code JavaScript qui communique avec un backend, et oĂč le backend se trouve dans une « origine » diffĂ©rente de celle du frontend.
## Origine { #origin }
* `allow_origins` - Une liste dâorigines autorisĂ©es Ă effectuer des requĂȘtes cross-origin. Par ex. `['https://example.org', 'https://www.example.org']`. Vous pouvez utiliser `['*']` pour autoriser nâimporte quelle origine.
* `allow_origin_regex` - Une chaĂźne regex pour faire correspondre les origines autorisĂ©es Ă effectuer des requĂȘtes cross-origin. Par ex. `'https://.*\.example\.org'`.
* `allow_methods` - Une liste de mĂ©thodes HTTP qui doivent ĂȘtre autorisĂ©es pour les requĂȘtes cross-origin. Par dĂ©faut `['GET']`. Vous pouvez utiliser `['*']` pour autoriser toutes les mĂ©thodes standard.
-* `allow_headers` - Une liste dâen-tĂȘtes HTTP de requĂȘte qui doivent ĂȘtre pris en charge pour les requĂȘtes cross-origin. Par dĂ©faut `[]`. Vous pouvez utiliser `['*']` pour autoriser tous les en-tĂȘtes. Les en-tĂȘtes `Accept`, `Accept-Language`, `Content-Language` et `Content-Type` sont toujours autorisĂ©s pour les <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS#simple_requests" class="external-link" rel="noopener" target="_blank">requĂȘtes CORS simples</a>.
+* `allow_headers` - Une liste dâen-tĂȘtes HTTP de requĂȘte qui doivent ĂȘtre pris en charge pour les requĂȘtes cross-origin. Par dĂ©faut `[]`. Vous pouvez utiliser `['*']` pour autoriser tous les en-tĂȘtes. Les en-tĂȘtes `Accept`, `Accept-Language`, `Content-Language` et `Content-Type` sont toujours autorisĂ©s pour les [requĂȘtes CORS simples](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS#simple_requests).
* `allow_credentials` - Indique que les cookies doivent ĂȘtre pris en charge pour les requĂȘtes cross-origin. Par dĂ©faut `False`.
- Aucun de `allow_origins`, `allow_methods` et `allow_headers` ne peut ĂȘtre dĂ©fini Ă `['*']` si `allow_credentials` est dĂ©fini Ă `True`. Ils doivent tous ĂȘtre <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS#credentialed_requests_and_wildcards" class="external-link" rel="noopener" target="_blank">spĂ©cifiĂ©s explicitement</a>.
+ Aucun de `allow_origins`, `allow_methods` et `allow_headers` ne peut ĂȘtre dĂ©fini Ă `['*']` si `allow_credentials` est dĂ©fini Ă `True`. Ils doivent tous ĂȘtre [spĂ©cifiĂ©s explicitement](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS#credentialed_requests_and_wildcards).
* `expose_headers` - Indique les en-tĂȘtes de rĂ©ponse qui doivent ĂȘtre accessibles au navigateur. Par dĂ©faut `[]`.
* `max_age` - Définit un temps maximum (en secondes) pendant lequel les navigateurs peuvent mettre en cache les réponses CORS. Par défaut `600`.
## En savoir plus { #more-info }
-Pour plus dâinformations sur <abbr title="Cross-Origin Resource Sharing - Partage des ressources entre origines">CORS</abbr>, consultez la <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS" class="external-link" target="_blank">documentation CORS de Mozilla</a>.
+Pour plus dâinformations sur <abbr title="Cross-Origin Resource Sharing - Partage des ressources entre origines">CORS</abbr>, consultez la [documentation CORS de Mozilla](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS).
/// note | DĂ©tails techniques
/// info
-Pour plus d'informations, consultez <a href="https://docs.python.org/3/library/__main__.html" class="external-link" target="_blank">la documentation officielle de Python</a>.
+Pour plus d'informations, consultez [la documentation officielle de Python](https://docs.python.org/3/library/__main__.html).
///
Dans cet exemple, nous utilisons des en-tĂȘtes personnalisĂ©s fictifs `X-Key` et `X-Token`.
-Mais dans des cas réels, lors de l'implémentation de la sécurité, vous tirerez davantage d'avantages en utilisant les [utilitaires de sécurité (chapitre suivant)](../security/index.md){.internal-link target=_blank} intégrés.
+Mais dans des cas réels, lors de l'implémentation de la sécurité, vous tirerez davantage d'avantages en utilisant les [utilitaires de sécurité (chapitre suivant)](../security/index.md) intégrés.
///
## Définir des dépendances pour un groupe de chemins d'accÚs { #dependencies-for-a-group-of-path-operations }
-Plus tard, en lisant comment structurer des applications plus grandes ([Applications plus grandes - Plusieurs fichiers](../../tutorial/bigger-applications.md){.internal-link target=_blank}), éventuellement avec plusieurs fichiers, vous apprendrez à déclarer un unique paramÚtre `dependencies` pour un groupe de *chemins d'accÚs*.
+Plus tard, en lisant comment structurer des applications plus grandes ([Applications plus grandes - Plusieurs fichiers](../../tutorial/bigger-applications.md)), éventuellement avec plusieurs fichiers, vous apprendrez à déclarer un unique paramÚtre `dependencies` pour un groupe de *chemins d'accÚs*.
## Définir des dépendances globales { #global-dependencies }
Toute fonction valide Ă utiliser avec :
-* <a href="https://docs.python.org/3/library/contextlib.html#contextlib.contextmanager" class="external-link" target="_blank">`@contextlib.contextmanager`</a> ou
-* <a href="https://docs.python.org/3/library/contextlib.html#contextlib.asynccontextmanager" class="external-link" target="_blank">`@contextlib.asynccontextmanager`</a>
+* [`@contextlib.contextmanager`](https://docs.python.org/3/library/contextlib.html#contextlib.contextmanager) ou
+* [`@contextlib.asynccontextmanager`](https://docs.python.org/3/library/contextlib.html#contextlib.asynccontextmanager)
sera valide comme dépendance **FastAPI**.
/// note | DĂ©tails techniques
-Cela fonctionne grĂące aux <a href="https://docs.python.org/3/library/contextlib.html" class="external-link" target="_blank">gestionnaires de contexte</a> de Python.
+Cela fonctionne grĂące aux [gestionnaires de contexte](https://docs.python.org/3/library/contextlib.html) de Python.
**FastAPI** les utilise en interne pour y parvenir.
{* ../../docs_src/dependencies/tutorial008b_an_py310.py hl[18:22,31] *}
-Si vous souhaitez intercepter des exceptions et créer une réponse personnalisée en fonction de cela, créez un [Gestionnaire d'exceptions personnalisé](../handling-errors.md#install-custom-exception-handlers){.internal-link target=_blank}.
+Si vous souhaitez intercepter des exceptions et créer une réponse personnalisée en fonction de cela, créez un [Gestionnaire d'exceptions personnalisé](../handling-errors.md#install-custom-exception-handlers).
## Utiliser des dépendances avec `yield` et `except` { #dependencies-with-yield-and-except }
Les dépendances avec `yield` ont évolué au fil du temps pour couvrir différents cas d'utilisation et corriger certains problÚmes.
-Si vous souhaitez voir ce qui a changé dans différentes versions de FastAPI, vous pouvez en savoir plus dans le guide avancé, dans [Dépendances avancées - Dépendances avec `yield`, `HTTPException`, `except` et Background Tasks](../../advanced/advanced-dependencies.md#dependencies-with-yield-httpexception-except-and-background-tasks){.internal-link target=_blank}.
+Si vous souhaitez voir ce qui a changé dans différentes versions de FastAPI, vous pouvez en savoir plus dans le guide avancé, dans [Dépendances avancées - Dépendances avec `yield`, `HTTPException`, `except` et Background Tasks](../../advanced/advanced-dependencies.md#dependencies-with-yield-httpexception-except-and-background-tasks).
## Gestionnaires de contexte { #context-managers }
### Que sont les « Context Managers » { #what-are-context-managers }
Les « Context Managers » sont des objets Python que vous pouvez utiliser dans une instruction `with`.
-Par exemple, <a href="https://docs.python.org/3/tutorial/inputoutput.html#reading-and-writing-files" class="external-link" target="_blank">vous pouvez utiliser `with` pour lire un fichier</a> :
+Par exemple, [vous pouvez utiliser `with` pour lire un fichier](https://docs.python.org/3/tutorial/inputoutput.html#reading-and-writing-files) :
```Python
with open("./somefile.txt") as f:
///
-En Python, vous pouvez créer des gestionnaires de contexte en <a href="https://docs.python.org/3/reference/datamodel.html#context-managers" class="external-link" target="_blank">créant une classe avec deux méthodes : `__enter__()` et `__exit__()`</a>.
+En Python, vous pouvez créer des gestionnaires de contexte en [créant une classe avec deux méthodes : `__enter__()` et `__exit__()`](https://docs.python.org/3/reference/datamodel.html#context-managers).
Vous pouvez également les utiliser dans des dépendances **FastAPI** avec `yield` en utilisant
des instructions `with` ou `async with` à l'intérieur de la fonction de dépendance :
Une autre façon de créer un gestionnaire de contexte consiste à utiliser :
-* <a href="https://docs.python.org/3/library/contextlib.html#contextlib.contextmanager" class="external-link" target="_blank">`@contextlib.contextmanager`</a> ou
-* <a href="https://docs.python.org/3/library/contextlib.html#contextlib.asynccontextmanager" class="external-link" target="_blank">`@contextlib.asynccontextmanager`</a>
+* [`@contextlib.contextmanager`](https://docs.python.org/3/library/contextlib.html#contextlib.contextmanager) ou
+* [`@contextlib.asynccontextmanager`](https://docs.python.org/3/library/contextlib.html#contextlib.asynccontextmanager)
pour décorer une fonction avec un unique `yield`.
Pour certains types d'applications, vous pourriez vouloir ajouter des dépendances à l'application entiÚre.
-Comme vous pouvez [ajouter des `dependencies` aux *décorateurs de chemin d'accÚs*](dependencies-in-path-operation-decorators.md){.internal-link target=_blank}, vous pouvez les ajouter à l'application `FastAPI`.
+Comme vous pouvez [ajouter des `dependencies` aux *décorateurs de chemin d'accÚs*](dependencies-in-path-operation-decorators.md), vous pouvez les ajouter à l'application `FastAPI`.
Dans ce cas, elles seront appliquées à tous les *chemins d'accÚs* de l'application :
{* ../../docs_src/dependencies/tutorial012_an_py310.py hl[17] *}
-Et toutes les idées de la section sur [l'ajout de `dependencies` aux *décorateurs de chemin d'accÚs*](dependencies-in-path-operation-decorators.md){.internal-link target=_blank} s'appliquent toujours, mais dans ce cas à tous les *chemins d'accÚs* de l'application.
+Et toutes les idées de la section sur [l'ajout de `dependencies` aux *décorateurs de chemin d'accÚs*](dependencies-in-path-operation-decorators.md) s'appliquent toujours, mais dans ce cas à tous les *chemins d'accÚs* de l'application.
## DĂ©pendances pour des groupes de *chemins d'accĂšs* { #dependencies-for-groups-of-path-operations }
-Plus tard, en lisant comment structurer des applications plus grandes ([Applications plus grandes - Plusieurs fichiers](../../tutorial/bigger-applications.md){.internal-link target=_blank}), éventuellement avec plusieurs fichiers, vous apprendrez comment déclarer un unique paramÚtre `dependencies` pour un groupe de *chemins d'accÚs*.
+Plus tard, en lisant comment structurer des applications plus grandes ([Applications plus grandes - Plusieurs fichiers](../../tutorial/bigger-applications.md)), éventuellement avec plusieurs fichiers, vous apprendrez comment déclarer un unique paramÚtre `dependencies` pour un groupe de *chemins d'accÚs*.
Puis elle retourne simplement un `dict` contenant ces valeurs.
-/// info | Info
+/// info
FastAPI a ajouté la prise en charge de `Annotated` (et a commencé à le recommander) dans la version 0.95.0.
Si vous avez une version plus ancienne, vous obtiendrez des erreurs en essayant dâutiliser `Annotated`.
-Vous devez vous assurer de [mettre Ă niveau la version de FastAPI](../../deployment/versions.md#upgrading-the-fastapi-versions){.internal-link target=_blank} vers au moins la 0.95.1 avant dâutiliser `Annotated`.
+Vous devez vous assurer de [mettre Ă niveau la version de FastAPI](../../deployment/versions.md#upgrading-the-fastapi-versions) vers au moins la 0.95.1 avant dâutiliser `Annotated`.
///
/// note | Remarque
-Si vous ne savez pas, consultez la section [Async : *« Pressé ? »*](../../async.md#in-a-hurry){.internal-link target=_blank} à propos de `async` et `await` dans la documentation.
+Si vous ne savez pas, consultez la section [Async : *« Pressé ? »*](../../async.md#in-a-hurry) à propos de `async` et `await` dans la documentation.
///
Par exemple, elle ne reçoit pas d'objets `datetime`, car ceux-ci ne sont pas compatibles avec JSON.
-Ainsi, un objet `datetime` doit ĂȘtre converti en une `str` contenant les donnĂ©es au <a href="https://en.wikipedia.org/wiki/ISO_8601" class="external-link" target="_blank">format ISO</a>.
+Ainsi, un objet `datetime` doit ĂȘtre converti en une `str` contenant les donnĂ©es au [format ISO](https://en.wikipedia.org/wiki/ISO_8601).
De la mĂȘme maniĂšre, cette base de donnĂ©es n'accepterait pas un modĂšle Pydantic (un objet avec des attributs), seulement un `dict`.
Dans cet exemple, elle convertirait le modĂšle Pydantic en `dict`, et le `datetime` en `str`.
-Le rĂ©sultat de son appel est quelque chose qui peut ĂȘtre encodĂ© avec la fonction standard de Python <a href="https://docs.python.org/3/library/json.html#json.dumps" class="external-link" target="_blank">`json.dumps()`</a>.
+Le rĂ©sultat de son appel est quelque chose qui peut ĂȘtre encodĂ© avec la fonction standard de Python [`json.dumps()`](https://docs.python.org/3/library/json.html#json.dumps).
Elle ne renvoie pas une grande `str` contenant les données au format JSON (sous forme de chaßne). Elle renvoie une structure de données standard de Python (par ex. un `dict`) avec des valeurs et sous-valeurs toutes compatibles avec JSON.
* `datetime.timedelta` :
* Un `datetime.timedelta` Python.
* Dans les requĂȘtes et les rĂ©ponses, il sera reprĂ©sentĂ© sous forme de `float` de secondes totales.
- * Pydantic permet aussi de le représenter sous la forme d'un « encodage de différence de temps ISO 8601 », <a href="https://docs.pydantic.dev/latest/concepts/serialization/#custom-serializers" class="external-link" target="_blank">voir la documentation pour plus d'informations</a>.
+ * Pydantic permet aussi de le représenter sous la forme d'un « encodage de différence de temps ISO 8601 », [voir la documentation pour plus d'informations](https://docs.pydantic.dev/latest/concepts/serialization/#custom-serializers).
* `frozenset` :
* Dans les requĂȘtes et les rĂ©ponses, traitĂ© de la mĂȘme maniĂšre qu'un `set` :
* Dans les requĂȘtes, une liste sera lue, les doublons Ă©liminĂ©s, puis convertie en `set`.
* `Decimal` :
* `Decimal` Python standard.
* Dans les requĂȘtes et les rĂ©ponses, gĂ©rĂ© de la mĂȘme maniĂšre qu'un `float`.
-* Vous pouvez consulter tous les types de données Pydantic valides ici : <a href="https://docs.pydantic.dev/latest/usage/types/types/" class="external-link" target="_blank">Types de données Pydantic</a>.
+* Vous pouvez consulter tous les types de données Pydantic valides ici : [Types de données Pydantic](https://docs.pydantic.dev/latest/usage/types/types/).
## Exemple { #example }
Ne stockez jamais les mots de passe des utilisateurs en clair. Stockez toujours un « hachage sécurisé » que vous pourrez ensuite vérifier.
-Si vous ne savez pas ce que c'est, vous apprendrez ce qu'est un « hachage de mot de passe » dans les [chapitres sur la sécurité](security/simple-oauth2.md#password-hashing){.internal-link target=_blank}.
+Si vous ne savez pas ce que c'est, vous apprendrez ce qu'est un « hachage de mot de passe » dans les [chapitres sur la sécurité](security/simple-oauth2.md#password-hashing).
///
Cela sera défini dans OpenAPI avec `anyOf`.
-Pour ce faire, utilisez l'annotation de type Python standard <a href="https://docs.python.org/3/library/typing.html#typing.Union" class="external-link" target="_blank">`typing.Union`</a>Â :
+Pour ce faire, utilisez l'annotation de type Python standard [`typing.Union`](https://docs.python.org/3/library/typing.html#typing.Union)Â :
/// note | Remarque
-Lors de la définition d'une <a href="https://docs.pydantic.dev/latest/concepts/types/#unions" class="external-link" target="_blank">`Union`</a>, incluez d'abord le type le plus spécifique, suivi du type le moins spécifique. Dans l'exemple ci-dessous, le type le plus spécifique `PlaneItem` précÚde `CarItem` dans `Union[PlaneItem, CarItem]`.
+Lors de la définition d'une [`Union`](https://docs.pydantic.dev/latest/concepts/types/#unions), incluez d'abord le type le plus spécifique, suivi du type le moins spécifique. Dans l'exemple ci-dessous, le type le plus spécifique `PlaneItem` précÚde `CarItem` dans `Union[PlaneItem, CarItem]`.
///
<div class="termy">
```console
-$ <font color="#4E9A06">fastapi</font> dev <u style="text-decoration-style:solid">main.py</u>
+$ <font color="#4E9A06">fastapi</font> dev
<span style="background-color:#009485"><font color="#D3D7CF"> FastAPI </font></span> Starting development server đ
### VĂ©rifier { #check-it }
-Ouvrez votre navigateur Ă lâadresse <a href="http://127.0.0.1:8000" class="external-link" target="_blank">http://127.0.0.1:8000</a>.
+Ouvrez votre navigateur Ă lâadresse [http://127.0.0.1:8000](http://127.0.0.1:8000).
Vous verrez la réponse JSON suivante :
### Documentation interactive de lâAPI { #interactive-api-docs }
-Allez maintenant sur <a href="http://127.0.0.1:8000/docs" class="external-link" target="_blank">http://127.0.0.1:8000/docs</a>.
+Allez maintenant sur [http://127.0.0.1:8000/docs](http://127.0.0.1:8000/docs).
-Vous verrez la documentation interactive de lâAPI gĂ©nĂ©rĂ©e automatiquement (fournie par <a href="https://github.com/swagger-api/swagger-ui" class="external-link" target="_blank">Swagger UI</a>) :
+Vous verrez la documentation interactive de lâAPI gĂ©nĂ©rĂ©e automatiquement (fournie par [Swagger UI](https://github.com/swagger-api/swagger-ui)) :
### Documentation alternative de lâAPI { #alternative-api-docs }
-Et maintenant, allez sur <a href="http://127.0.0.1:8000/redoc" class="external-link" target="_blank">http://127.0.0.1:8000/redoc</a>.
+Et maintenant, allez sur [http://127.0.0.1:8000/redoc](http://127.0.0.1:8000/redoc).
-Vous verrez la documentation automatique alternative (fournie par <a href="https://github.com/Rebilly/ReDoc" class="external-link" target="_blank">ReDoc</a>) :
+Vous verrez la documentation automatique alternative (fournie par [ReDoc](https://github.com/Rebilly/ReDoc)) :
#### « SchĂ©ma » dâAPI { #api-schema }
-Ici, <a href="https://github.com/OAI/OpenAPI-Specification" class="external-link" target="_blank">OpenAPI</a> est une spécification qui dicte comment définir le schéma de votre API.
+Ici, [OpenAPI](https://github.com/OAI/OpenAPI-Specification) est une spécification qui dicte comment définir le schéma de votre API.
Cette dĂ©finition de schĂ©ma inclut les chemins de votre API, les paramĂštres possibles quâils prennent, etc.
Si vous ĂȘtes curieux de voir Ă quoi ressemble le schĂ©ma OpenAPI brut, FastAPI gĂ©nĂšre automatiquement un JSON (schĂ©ma) avec les descriptions de toute votre API.
-Vous pouvez le voir directement Ă lâadresse : <a href="http://127.0.0.1:8000/openapi.json" class="external-link" target="_blank">http://127.0.0.1:8000/openapi.json</a>.
+Vous pouvez le voir directement Ă lâadresse : [http://127.0.0.1:8000/openapi.json](http://127.0.0.1:8000/openapi.json).
Il affichera un JSON commençant par quelque chose comme :
Vous pourriez Ă©galement lâutiliser pour gĂ©nĂ©rer du code automatiquement, pour les clients qui communiquent avec votre API. Par exemple, des applications frontend, mobiles ou IoT.
+### Configurer le `entrypoint` de lâapplication dans `pyproject.toml` { #configure-the-app-entrypoint-in-pyproject-toml }
+
+Vous pouvez configurer lâemplacement de votre application dans un fichier `pyproject.toml` commeâŻ:
+
+```toml
+[tool.fastapi]
+entrypoint = "main:app"
+```
+
+Ce `entrypoint` indiquera Ă la commande `fastapi` quâelle doit importer lâapplication commeâŻ:
+
+```python
+from main import app
+```
+
+Si votre code est structurĂ© commeâŻ:
+
+```
+.
+âââ backend
+â  âââ main.py
+â  âââ __init__.py
+```
+
+Alors vous dĂ©finiriez le `entrypoint` commeâŻ:
+
+```toml
+[tool.fastapi]
+entrypoint = "backend.main:app"
+```
+
+ce qui Ă©quivaudrait Ă âŻ:
+
+```python
+from backend.main import app
+```
+
+### `fastapi dev` avec un chemin { #fastapi-dev-with-path }
+
+Vous pouvez Ă©galement passer le chemin du fichier Ă la commande `fastapi dev`, et elle devinera lâobjet dâapplication FastAPI Ă utiliserâŻ:
+
+```console
+$ fastapi dev main.py
+```
+
+Mais vous devrez vous souvenir de passer le chemin correct à chaque exécution de la commande `fastapi`.
+
+De plus, dâautres outils pourraient ne pas ĂȘtre capables de le trouver, par exemple lâ[Extension VS Code](../editor-support.md) ou [FastAPI Cloud](https://fastapicloud.com), il est donc recommandĂ© dâutiliser le `entrypoint` dans `pyproject.toml`.
+
### DĂ©ployer votre application (optionnel) { #deploy-your-app-optional }
-Vous pouvez, si vous le souhaitez, dĂ©ployer votre application FastAPI sur <a href="https://fastapicloud.com" class="external-link" target="_blank">FastAPI Cloud</a>, allez rejoindre la liste dâattente si ce nâest pas dĂ©jĂ fait. đ
+Vous pouvez, si vous le souhaitez, dĂ©ployer votre application FastAPI sur [FastAPI Cloud](https://fastapicloud.com), allez rejoindre la liste dâattente si ce nâest pas dĂ©jĂ fait. đ
Si vous avez dĂ©jĂ un compte **FastAPI Cloud** (nous vous avons invitĂ© depuis la liste dâattente đ), vous pouvez dĂ©ployer votre application avec une seule commande.
`FastAPI` est une classe qui hérite directement de `Starlette`.
-Vous pouvez donc aussi utiliser toutes les fonctionnalités de <a href="https://www.starlette.dev/" class="external-link" target="_blank">Starlette</a> avec `FastAPI`.
+Vous pouvez donc aussi utiliser toutes les fonctionnalités de [Starlette](https://www.starlette.dev/) avec `FastAPI`.
///
/// note | Remarque
-Si vous ne connaissez pas la différence, consultez [Asynchrone : « Pressé ? »](../async.md#in-a-hurry){.internal-link target=_blank}.
+Si vous ne connaissez pas la différence, consultez [Asynchrone : « Pressé ? »](../async.md#in-a-hurry).
///
### Ătape 6 : le dĂ©ployer { #step-6-deploy-it }
-DĂ©ployez votre application sur **<a href="https://fastapicloud.com" class="external-link" target="_blank">FastAPI Cloud</a>** avec une seule commande : `fastapi deploy`. đ
+DĂ©ployez votre application sur **[FastAPI Cloud](https://fastapicloud.com)** avec une seule commande : `fastapi deploy`. đ
#### Ă propos de FastAPI Cloud { #about-fastapi-cloud }
-**<a href="https://fastapicloud.com" class="external-link" target="_blank">FastAPI Cloud</a>** est construit par le mĂȘme auteur et lâĂ©quipe derriĂšre **FastAPI**.
+**[FastAPI Cloud](https://fastapicloud.com)** est construit par le mĂȘme auteur et lâĂ©quipe derriĂšre **FastAPI**.
Il simplifie le processus de **construction**, de **dĂ©ploiement** et dâ**accĂšs** Ă une API avec un minimum dâeffort.
## Installer des gestionnaires d'exception personnalisés { #install-custom-exception-handlers }
-Vous pouvez ajouter des gestionnaires d'exception personnalisĂ©s avec <a href="https://www.starlette.dev/exceptions/" class="external-link" target="_blank">les mĂȘmes utilitaires d'exception de Starlette</a>.
+Vous pouvez ajouter des gestionnaires d'exception personnalisĂ©s avec [les mĂȘmes utilitaires d'exception de Starlette](https://www.starlette.dev/exceptions/).
Supposons que vous ayez une exception personnalisée `UnicornException` que vous (ou une bibliothÚque que vous utilisez) pourriez `raise`.
Tous les blocs de code peuvent ĂȘtre copiĂ©s et utilisĂ©s directement (il s'agit en fait de fichiers Python testĂ©s).
-Pour exécuter l'un de ces exemples, copiez le code dans un fichier `main.py`, et démarrez `fastapi dev` avec :
+Pour exécuter l'un de ces exemples, copiez le code dans un fichier `main.py`, et démarrez `fastapi dev` :
<div class="termy">
```console
-$ <font color="#4E9A06">fastapi</font> dev <u style="text-decoration-style:solid">main.py</u>
+$ <font color="#4E9A06">fastapi</font> dev
<span style="background-color:#009485"><font color="#D3D7CF"> FastAPI </font></span> Starting development server đ
La premiĂšre Ă©tape consiste Ă installer FastAPI.
-Assurez-vous de créer un [environnement virtuel](../virtual-environments.md){.internal-link target=_blank}, de l'activer, puis **d'installer FastAPI** :
+Assurez-vous de créer un [environnement virtuel](../virtual-environments.md), de l'activer, puis **d'installer FastAPI** :
<div class="termy">
/// note | Remarque
-Lorsque vous installez avec `pip install "fastapi[standard]"` cela inclut des dépendances standard optionnelles par défaut, y compris `fastapi-cloud-cli`, qui vous permet de déployer sur <a href="https://fastapicloud.com" class="external-link" target="_blank">FastAPI Cloud</a>.
+Lorsque vous installez avec `pip install "fastapi[standard]"`, cela inclut des dépendances standards optionnelles par défaut, y compris `fastapi-cloud-cli`, qui vous permet de déployer sur [FastAPI Cloud](https://fastapicloud.com).
Si vous ne souhaitez pas avoir ces dépendances optionnelles, vous pouvez à la place installer `pip install fastapi`.
///
+/// tip | Astuce
+
+FastAPI dispose d'une [extension officielle pour VS Code](https://marketplace.visualstudio.com/items?itemName=FastAPILabs.fastapi-vscode) (et Cursor), qui fournit de nombreuses fonctionnalités, notamment un explorateur de chemins d'accÚs, une recherche de chemins d'accÚs, la navigation CodeLens dans les tests (aller à la définition depuis les tests), ainsi que le déploiement et les journaux FastAPI Cloud, le tout depuis votre éditeur.
+
+///
+
## Guide d'utilisation avancé { #advanced-user-guide }
Il existe également un **Guide d'utilisation avancé** que vous pouvez lire plus tard aprÚs ce **Tutoriel - Guide d'utilisation**.
| `version` | `string` | La version de lâAPI. Câest la version de votre propre application, pas dâOpenAPI. Par exemple `2.5.0`. |
| `terms_of_service` | `str` | Une URL vers les Conditions dâutilisation de lâAPI. Le cas Ă©chĂ©ant, il doit sâagir dâune URL. |
| `contact` | `dict` | Les informations de contact pour lâAPI exposĂ©e. Cela peut contenir plusieurs champs. <details><summary>champs de <code>contact</code></summary><table><thead><tr><th>ParamĂštre</th><th>Type</th><th>Description</th></tr></thead><tbody><tr><td><code>name</code></td><td><code>str</code></td><td>Le nom identifiant de la personne/organisation de contact.</td></tr><tr><td><code>url</code></td><td><code>str</code></td><td>LâURL pointant vers les informations de contact. DOIT ĂȘtre au format dâune URL.</td></tr><tr><td><code>email</code></td><td><code>str</code></td><td>Lâadresse e-mail de la personne/organisation de contact. DOIT ĂȘtre au format dâune adresse e-mail.</td></tr></tbody></table></details> |
-| `license_info` | `dict` | Les informations de licence pour lâAPI exposĂ©e. Cela peut contenir plusieurs champs. <details><summary>champs de <code>license_info</code></summary><table><thead><tr><th>ParamĂštre</th><th>Type</th><th>Description</th></tr></thead><tbody><tr><td><code>name</code></td><td><code>str</code></td><td><strong>OBLIGATOIRE</strong> (si un <code>license_info</code> est dĂ©fini). Le nom de la licence utilisĂ©e pour lâAPI.</td></tr><tr><td><code>identifier</code></td><td><code>str</code></td><td>Une expression de licence <a href="https://spdx.org/licenses/" class="external-link" target="_blank">SPDX</a> pour lâAPI. Le champ <code>identifier</code> est mutuellement exclusif du champ <code>url</code>. <small>Disponible depuis OpenAPI 3.1.0, FastAPI 0.99.0.</small></td></tr><tr><td><code>url</code></td><td><code>str</code></td><td>Une URL vers la licence utilisĂ©e pour lâAPI. DOIT ĂȘtre au format dâune URL.</td></tr></tbody></table></details> |
+| `license_info` | `dict` | Les informations de licence pour lâAPI exposĂ©e. Cela peut contenir plusieurs champs. <details><summary>champs de <code>license_info</code></summary><table><thead><tr><th>ParamĂštre</th><th>Type</th><th>Description</th></tr></thead><tbody><tr><td><code>name</code></td><td><code>str</code></td><td><strong>OBLIGATOIRE</strong> (si un <code>license_info</code> est dĂ©fini). Le nom de la licence utilisĂ©e pour lâAPI.</td></tr><tr><td><code>identifier</code></td><td><code>str</code></td><td>Une expression de licence [SPDX](https://spdx.org/licenses/) pour lâAPI. Le champ <code>identifier</code> est mutuellement exclusif du champ <code>url</code>. <small>Disponible depuis OpenAPI 3.1.0, FastAPI 0.99.0.</small></td></tr><tr><td><code>url</code></td><td><code>str</code></td><td>Une URL vers la licence utilisĂ©e pour lâAPI. DOIT ĂȘtre au format dâune URL.</td></tr></tbody></table></details> |
Vous pouvez les définir comme suit :
/// info
-En savoir plus sur les tags dans [Configuration de chemins d'accĂšs](path-operation-configuration.md#tags){.internal-link target=_blank}.
+En savoir plus sur les tags dans [Configuration de chemins d'accĂšs](path-operation-configuration.md#tags).
///
Si vous avez des dĂ©pendances avec `yield`, le code de sortie sâexĂ©cutera aprĂšs le middleware.
-Sâil y avait des tĂąches dâarriĂšre-plan (prĂ©sentĂ©es dans la section [TĂąches dâarriĂšre-plan](background-tasks.md){.internal-link target=_blank}, que vous verrez plus tard), elles sâexĂ©cuteront aprĂšs tous les middlewares.
+Sâil y avait des tĂąches dâarriĂšre-plan (prĂ©sentĂ©es dans la section [TĂąches dâarriĂšre-plan](background-tasks.md), que vous verrez plus tard), elles sâexĂ©cuteront aprĂšs tous les middlewares.
///
/// tip | Astuce
-Gardez Ă lâesprit que des en-tĂȘtes propriĂ©taires personnalisĂ©s peuvent ĂȘtre ajoutĂ©s <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers" class="external-link" target="_blank">en utilisant le prĂ©fixe `X-`</a>.
+Gardez Ă lâesprit que des en-tĂȘtes propriĂ©taires personnalisĂ©s peuvent ĂȘtre ajoutĂ©s [en utilisant le prĂ©fixe `X-`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers).
-Mais si vous avez des en-tĂȘtes personnalisĂ©s que vous voulez rendre visibles pour un client dans un navigateur, vous devez les ajouter Ă votre configuration CORS ([CORS (Partage des ressources entre origines)](cors.md){.internal-link target=_blank}) en utilisant le paramĂštre `expose_headers` documentĂ© dans <a href="https://www.starlette.dev/middleware/#corsmiddleware" class="external-link" target="_blank">la documentation CORS de Starlette</a>.
+Mais si vous avez des en-tĂȘtes personnalisĂ©s que vous voulez rendre visibles pour un client dans un navigateur, vous devez les ajouter Ă votre configuration CORS ([CORS (Partage des ressources entre origines)](cors.md)) en utilisant le paramĂštre `expose_headers` documentĂ© dans [la documentation CORS de Starlette](https://www.starlette.dev/middleware/#corsmiddleware).
///
/// tip | Astuce
-Ici, nous utilisons <a href="https://docs.python.org/3/library/time.html#time.perf_counter" class="external-link" target="_blank">`time.perf_counter()`</a> au lieu de `time.time()` car cela peut ĂȘtre plus prĂ©cis pour ces cas dâusage. đ€
+Ici, nous utilisons [`time.perf_counter()`](https://docs.python.org/3/library/time.html#time.perf_counter) au lieu de `time.time()` car cela peut ĂȘtre plus prĂ©cis pour ces cas dâusage. đ€
///
## Autres middlewares { #other-middlewares }
-Vous pouvez en lire davantage sur dâautres middlewares dans le [Guide de lâutilisateur avancĂ© : Middleware avancĂ©](../advanced/middleware.md){.internal-link target=_blank}.
+Vous pouvez en lire davantage sur dâautres middlewares dans le [Guide de lâutilisateur avancĂ© : Middleware avancĂ©](../advanced/middleware.md).
Vous verrez comment gérer <abbr title="Cross-Origin Resource Sharing - Partage des ressources entre origines">CORS</abbr> avec un middleware dans la section suivante.
Comme les descriptions ont tendance Ă ĂȘtre longues et Ă couvrir plusieurs lignes, vous pouvez dĂ©clarer la description du *chemin d'accĂšs* dans la <dfn title="une chaĂźne multilignes comme premiĂšre expression Ă l'intĂ©rieur d'une fonction (non assignĂ©e Ă une variable) utilisĂ©e pour la documentation">docstring</dfn> de la fonction et **FastAPI** la lira Ă partir de lĂ .
-Vous pouvez écrire <a href="https://en.wikipedia.org/wiki/Markdown" class="external-link" target="_blank">Markdown</a> dans la docstring, il sera interprété et affiché correctement (en tenant compte de l'indentation de la docstring).
+Vous pouvez écrire [Markdown](https://en.wikipedia.org/wiki/Markdown) dans la docstring, il sera interprété et affiché correctement (en tenant compte de l'indentation de la docstring).
{* ../../docs_src/path_operation_configuration/tutorial004_py310.py hl[17:25] *}
Si vous avez une version plus ancienne, vous obtiendrez des erreurs en essayant d'utiliser `Annotated`.
-Assurez-vous de [Mettre Ă niveau la version de FastAPI](../deployment/versions.md#upgrading-the-fastapi-versions){.internal-link target=_blank} Ă la version 0.95.1 Ă minima avant d'utiliser `Annotated`.
+Assurez-vous de [Mettre Ă niveau la version de FastAPI](../deployment/versions.md#upgrading-the-fastapi-versions) Ă la version 0.95.1 Ă minima avant d'utiliser `Annotated`.
///
Les validations numériques fonctionnent également pour les valeurs `float`.
-C'est ici qu'il devient important de pouvoir dĂ©clarer <abbr title="greater than"><code>gt</code></abbr> et pas seulement <abbr title="greater than or equal"><code>ge</code></abbr>. Avec cela, vous pouvez exiger, par exemple, qu'une valeur doit ĂȘtre supĂ©rieure Ă `0`, mĂȘme si elle est infĂ©rieure Ă `1`.
+C'est ici qu'il devient important de pouvoir dĂ©clarer <abbr title="greater than - supĂ©rieur Ă "><code>gt</code></abbr> et pas seulement <abbr title="greater than or equal - supĂ©rieur ou Ă©gal"><code>ge</code></abbr>. Avec cela, vous pouvez exiger, par exemple, qu'une valeur doit ĂȘtre supĂ©rieure Ă `0`, mĂȘme si elle est infĂ©rieure Ă `1`.
Ainsi, `0.5` serait une valeur valide. Mais `0.0` ou `0` ne le serait pas.
-Et la mĂȘme chose pour <abbr title="less than"><code>lt</code></abbr>.
+Et la mĂȘme chose pour <abbr title="less than - infĂ©rieur Ă "><code>lt</code></abbr>.
{* ../../docs_src/path_params_numeric_validations/tutorial006_an_py310.py hl[13] *}
## Pour résumer { #recap }
-Avec `Query`, `Path` (et d'autres que vous verrez plus tard) vous pouvez dĂ©clarer des mĂ©tadonnĂ©es et des validations de chaĂźnes de la mĂȘme maniĂšre qu'avec les [ParamĂštres de requĂȘte et validations de chaĂźnes](query-params-str-validations.md){.internal-link target=_blank}.
+Avec `Query`, `Path` (et d'autres que vous verrez plus tard) vous pouvez dĂ©clarer des mĂ©tadonnĂ©es et des validations de chaĂźnes de la mĂȘme maniĂšre qu'avec les [ParamĂštres de requĂȘte et validations de chaĂźnes](query-params-str-validations.md).
Et vous pouvez également déclarer des validations numériques :
La valeur du paramĂštre de chemin `item_id` sera transmise Ă votre fonction dans l'argument `item_id`.
-Donc, si vous exécutez cet exemple et allez sur <a href="http://127.0.0.1:8000/items/foo" class="external-link" target="_blank">http://127.0.0.1:8000/items/foo</a>, vous verrez comme réponse :
+Donc, si vous exécutez cet exemple et allez sur [http://127.0.0.1:8000/items/foo](http://127.0.0.1:8000/items/foo), vous verrez comme réponse :
```JSON
{"item_id":"foo"}
## <dfn title="également appelé : sérialisation, parsing, marshalling">Conversion</dfn> de données { #data-conversion }
-Si vous exécutez cet exemple et ouvrez votre navigateur sur <a href="http://127.0.0.1:8000/items/3" class="external-link" target="_blank">http://127.0.0.1:8000/items/3</a>, vous verrez comme réponse :
+Si vous exécutez cet exemple et ouvrez votre navigateur sur [http://127.0.0.1:8000/items/3](http://127.0.0.1:8000/items/3), vous verrez comme réponse :
```JSON
{"item_id":3}
## Validation de données { #data-validation }
-Mais si vous allez dans le navigateur sur <a href="http://127.0.0.1:8000/items/foo" class="external-link" target="_blank">http://127.0.0.1:8000/items/foo</a>, vous verrez une belle erreur HTTP :
+Mais si vous allez dans le navigateur sur [http://127.0.0.1:8000/items/foo](http://127.0.0.1:8000/items/foo), vous verrez une belle erreur HTTP :
```JSON
{
car le paramÚtre de chemin `item_id` a pour valeur « foo », qui n'est pas un `int`.
-La mĂȘme erreur apparaĂźtrait si vous fournissiez un `float` au lieu d'un `int`, comme ici : <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>
+La mĂȘme erreur apparaĂźtrait si vous fournissiez un `float` au lieu d'un `int`, comme ici : [http://127.0.0.1:8000/items/4.2](http://127.0.0.1:8000/items/4.2)
/// check | VĂ©rifications
## Documentation { #documentation }
-Et lorsque vous ouvrez votre navigateur sur <a href="http://127.0.0.1:8000/docs" class="external-link" target="_blank">http://127.0.0.1:8000/docs</a>, vous verrez une documentation d'API automatique et interactive comme :
+Et lorsque vous ouvrez votre navigateur sur [http://127.0.0.1:8000/docs](http://127.0.0.1:8000/docs), vous verrez une documentation d'API automatique et interactive comme :
<img src="/img/tutorial/path-params/image01.png">
## Les avantages d'une norme, documentation alternative { #standards-based-benefits-alternative-documentation }
-Et comme le schéma généré suit la norme <a href="https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md" class="external-link" target="_blank">OpenAPI</a>, il existe de nombreux outils compatibles.
+Et comme le schéma généré suit la norme [OpenAPI](https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md), il existe de nombreux outils compatibles.
-GrĂące Ă cela, **FastAPI** fournit lui-mĂȘme une documentation d'API alternative (utilisant ReDoc), accessible sur <a href="http://127.0.0.1:8000/redoc" class="external-link" target="_blank">http://127.0.0.1:8000/redoc</a> :
+GrĂące Ă cela, **FastAPI** fournit lui-mĂȘme une documentation d'API alternative (utilisant ReDoc), accessible sur [http://127.0.0.1:8000/redoc](http://127.0.0.1:8000/redoc) :
<img src="/img/tutorial/path-params/image02.png">
## Pydantic { #pydantic }
-Toute la validation de donnĂ©es est effectuĂ©e sous le capot par <a href="https://docs.pydantic.dev/" class="external-link" target="_blank">Pydantic</a>, vous en bĂ©nĂ©ficiez donc pleinement. Vous savez ainsi que vous ĂȘtes entre de bonnes mains.
+Toute la validation de donnĂ©es est effectuĂ©e sous le capot par [Pydantic](https://docs.pydantic.dev/), vous en bĂ©nĂ©ficiez donc pleinement. Vous savez ainsi que vous ĂȘtes entre de bonnes mains.
Vous pouvez utiliser les mĂȘmes dĂ©clarations de type avec `str`, `float`, `bool` et de nombreux autres types de donnĂ©es complexes.
## Valeurs prédéfinies { #predefined-values }
-Si vous avez un *chemin d'accĂšs* qui reçoit un *paramĂštre de chemin*, mais que vous voulez que les valeurs possibles de ce *paramĂštre de chemin* soient prĂ©dĂ©finies, vous pouvez utiliser une <abbr title="Enumeration - ĂnumĂ©ration">`Enum`</abbr> Python standard.
+Si vous avez un *chemin d'accĂšs* qui reçoit un *paramĂštre de chemin*, mais que vous voulez que les valeurs possibles de ce *paramĂštre de chemin* soient prĂ©dĂ©finies, vous pouvez utiliser une <abbr title="ĂnumĂ©ration">`Enum`</abbr> Python standard.
### Créer une classe `Enum` { #create-an-enum-class }
Si vous avez une version plus ancienne, vous obtiendrez des erreurs en essayant dâutiliser `Annotated`.
-Assurez-vous de [mettre Ă niveau la version de FastAPI](../deployment/versions.md#upgrading-the-fastapi-versions){.internal-link target=_blank} vers au moins 0.95.1 avant dâutiliser `Annotated`.
+Assurez-vous de [mettre Ă niveau la version de FastAPI](../deployment/versions.md#upgrading-the-fastapi-versions) vers au moins 0.95.1 avant dâutiliser `Annotated`.
///
## Utiliser `Annotated` dans le type pour le paramĂštre `q` { #use-annotated-in-the-type-for-the-q-parameter }
-Vous vous souvenez que je vous ai dit plus tĂŽt que `Annotated` peut ĂȘtre utilisĂ© pour ajouter des mĂ©tadonnĂ©es Ă vos paramĂštres dans lâ[Introduction aux types Python](../python-types.md#type-hints-with-metadata-annotations){.internal-link target=_blank} ?
+Vous vous souvenez que je vous ai dit plus tĂŽt que `Annotated` peut ĂȘtre utilisĂ© pour ajouter des mĂ©tadonnĂ©es Ă vos paramĂštres dans lâ[Introduction aux types Python](../python-types.md#type-hints-with-metadata-annotations) ?
Câest le moment de lâutiliser avec FastAPI. đ
Quand vous nâutilisez pas `Annotated` et utilisez Ă la place lâ**ancienne** mĂ©thode avec la **valeur par dĂ©faut**, si vous appelez cette fonction sans FastAPI dans **dâautres endroits**, vous devez **penser** Ă passer les arguments Ă la fonction pour quâelle fonctionne correctement, sinon les valeurs seront diffĂ©rentes de ce que vous attendez (par ex. `QueryInfo` ou quelque chose de similaire au lieu dâune `str`). Et votre Ă©diteur ne se plaindra pas, et Python ne se plaindra pas en exĂ©cutant cette fonction, seulement quand les opĂ©rations internes Ă©choueront.
-Comme `Annotated` peut avoir plus dâune annotation de mĂ©tadonnĂ©es, vous pouvez maintenant mĂȘme utiliser la mĂȘme fonction avec dâautres outils, comme <a href="https://typer.tiangolo.com/" class="external-link" target="_blank">Typer</a>. đ
+Comme `Annotated` peut avoir plus dâune annotation de mĂ©tadonnĂ©es, vous pouvez maintenant mĂȘme utiliser la mĂȘme fonction avec dâautres outils, comme [Typer](https://typer.tiangolo.com/). đ
## Ajouter plus de validations { #add-more-validations }
Dans ces cas, vous pouvez utiliser une **fonction de validation personnalisée** qui est appliquée aprÚs la validation normale (par ex. aprÚs avoir validé que la valeur est une `str`).
-Vous pouvez y parvenir en utilisant <a href="https://docs.pydantic.dev/latest/concepts/validators/#field-after-validator" class="external-link" target="_blank">`AfterValidator` de Pydantic</a> Ă lâintĂ©rieur de `Annotated`.
+Vous pouvez y parvenir en utilisant [`AfterValidator` de Pydantic](https://docs.pydantic.dev/latest/concepts/validators/#field-after-validator) Ă lâintĂ©rieur de `Annotated`.
/// tip | Astuce
-Pydantic a aussi <a href="https://docs.pydantic.dev/latest/concepts/validators/#field-before-validator" class="external-link" target="_blank">`BeforeValidator`</a> et dâautres. đ€
+Pydantic a aussi [`BeforeValidator`](https://docs.pydantic.dev/latest/concepts/validators/#field-before-validator) et dâautres. đ€
///
## Multiples paramĂštres de chemin et de requĂȘte { #multiple-path-and-query-parameters }
-Vous pouvez dĂ©clarer plusieurs paramĂštres de chemin et paramĂštres de requĂȘte en mĂȘme temps, FastAPI sait lequel est lequel.
+Vous pouvez dĂ©clarer plusieurs paramĂštres de chemin et paramĂštres de requĂȘte en mĂȘme temps, **FastAPI** sait lequel est lequel.
Et vous n'avez pas besoin de les déclarer dans un ordre spécifique.
/// tip | Astuce
-Vous pourriez aussi utiliser des `Enum`s de la mĂȘme façon qu'avec les [ParamĂštres de chemin](path-params.md#predefined-values){.internal-link target=_blank}.
+Vous pourriez aussi utiliser des `Enum`s de la mĂȘme façon qu'avec les [ParamĂštres de chemin](path-params.md#predefined-values).
///
/// info
-Pour recevoir des fichiers téléversés, installez d'abord <a href="https://github.com/Kludex/python-multipart" class="external-link" target="_blank">`python-multipart`</a>.
+Pour recevoir des fichiers téléversés, installez d'abord [`python-multipart`](https://github.com/Kludex/python-multipart).
-Assurez-vous de créer un [environnement virtuel](../virtual-environments.md){.internal-link target=_blank}, de l'activer, puis d'installer le paquet, par exemple :
+Assurez-vous de créer un [environnement virtuel](../virtual-environments.md), de l'activer, puis d'installer le paquet, par exemple :
```console
$ pip install python-multipart
- Un fichier stocké en mémoire jusqu'à une taille maximale, puis, au-delà de cette limite, stocké sur le disque.
- Cela fonctionne donc bien pour des fichiers volumineux comme des images, des vidéos, de gros binaires, etc., sans consommer toute la mémoire.
- Vous pouvez obtenir des métadonnées à partir du fichier téléversé.
-- Il offre une interface `async` de type <a href="https://docs.python.org/3/glossary.html#term-file-like-object" class="external-link" target="_blank">file-like</a>.
-- Il expose un véritable objet Python <a href="https://docs.python.org/3/library/tempfile.html#tempfile.SpooledTemporaryFile" class="external-link" target="_blank">`SpooledTemporaryFile`</a> que vous pouvez passer directement à d'autres bibliothÚques qui attendent un objet « file-like ».
+- Il offre une interface `async` de type [file-like](https://docs.python.org/3/glossary.html#term-file-like-object).
+- Il expose un véritable objet Python [`SpooledTemporaryFile`](https://docs.python.org/3/library/tempfile.html#tempfile.SpooledTemporaryFile) que vous pouvez passer directement à d'autres bibliothÚques qui attendent un objet « file-like ».
### `UploadFile` { #uploadfile }
- `filename` : une `str` contenant le nom de fichier original téléversé (par ex. `myimage.jpg`).
- `content_type` : une `str` avec le type de contenu (type MIME / type média) (par ex. `image/jpeg`).
-- `file` : un <a href="https://docs.python.org/3/library/tempfile.html#tempfile.SpooledTemporaryFile" class="external-link" target="_blank">`SpooledTemporaryFile`</a> (un objet <a href="https://docs.python.org/3/glossary.html#term-file-like-object" class="external-link" target="_blank">de type fichier</a>). C'est l'objet fichier Python réel que vous pouvez passer directement à d'autres fonctions ou bibliothÚques qui attendent un objet « file-like ».
+- `file` : un [`SpooledTemporaryFile`](https://docs.python.org/3/library/tempfile.html#tempfile.SpooledTemporaryFile) (un objet [file-like](https://docs.python.org/3/glossary.html#term-file-like-object)). C'est l'objet fichier Python réel que vous pouvez passer directement à d'autres fonctions ou bibliothÚques qui attendent un objet « file-like ».
`UploadFile` a les méthodes `async` suivantes. Elles appellent toutes les méthodes correspondantes du fichier sous-jacent (en utilisant le `SpooledTemporaryFile` interne).
Mais lorsque le formulaire inclut des fichiers, il est encodé en `multipart/form-data`. Si vous utilisez `File`, **FastAPI** saura qu'il doit récupérer les fichiers depuis la partie appropriée du corps.
-Si vous souhaitez en savoir plus sur ces encodages et les champs de formulaire, consultez la <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/POST" class="external-link" target="_blank"><abbr title="Mozilla Developer Network - Réseau des développeurs Mozilla">MDN</abbr> Web Docs pour <code>POST</code></a>.
+Si vous souhaitez en savoir plus sur ces encodages et les champs de formulaire, consultez la [<abbr title="Mozilla Developer Network - Réseau des développeurs Mozilla">MDN</abbr> Web Docs pour `POST`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/POST).
///
/// info
-Pour utiliser les formulaires, installez d'abord <a href="https://github.com/Kludex/python-multipart" class="external-link" target="_blank">`python-multipart`</a>.
+Pour utiliser les formulaires, installez d'abord [`python-multipart`](https://github.com/Kludex/python-multipart).
-Assurez-vous de créer un [environnement virtuel](../virtual-environments.md){.internal-link target=_blank}, de l'activer, puis d'installer le paquet, par exemple :
+Assurez-vous de créer un [environnement virtuel](../virtual-environments.md), de l'activer, puis d'installer le paquet, par exemple :
```console
$ pip install python-multipart
/// info
-Pour recevoir des fichiers téléversés et/ou des données de formulaire, installez d'abord <a href="https://github.com/Kludex/python-multipart" class="external-link" target="_blank">`python-multipart`</a>.
+Pour recevoir des fichiers téléversés et/ou des données de formulaire, installez d'abord [`python-multipart`](https://github.com/Kludex/python-multipart).
-Vous devez créer un [environnement virtuel](../virtual-environments.md){.internal-link target=_blank}, l'activer, puis installer ce paquet, par exemple :
+Vous devez créer un [environnement virtuel](../virtual-environments.md), l'activer, puis installer ce paquet, par exemple :
```console
$ pip install python-multipart
/// info
-Pour utiliser les formulaires, installez d'abord <a href="https://github.com/Kludex/python-multipart" class="external-link" target="_blank">`python-multipart`</a>.
+Pour utiliser les formulaires, installez d'abord [`python-multipart`](https://github.com/Kludex/python-multipart).
-Assurez-vous de créer un [environnement virtuel](../virtual-environments.md){.internal-link target=_blank}, de l'activer, puis d'installer ce paquet, par exemple :
+Assurez-vous de créer un [environnement virtuel](../virtual-environments.md), de l'activer, puis installez-le, par exemple :
```console
$ pip install python-multipart
Mais lorsque le formulaire inclut des fichiers, il est encodé en `multipart/form-data`. Vous lirez la gestion des fichiers dans le chapitre suivant.
-Si vous voulez en savoir plus sur ces encodages et les champs de formulaire, consultez la <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/POST" class="external-link" target="_blank"><abbr title="Mozilla Developer Network - Réseau des développeurs Mozilla">MDN</abbr> web docs pour <code>POST</code></a>.
+Si vous voulez en savoir plus sur ces encodages et les champs de formulaire, consultez la [<abbr title="Mozilla Developer Network - Réseau des développeurs Mozilla">MDN</abbr> web docs pour `POST`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/POST).
///
* Ajouter un **JSON Schema** pour la rĂ©ponse, dans lâOpenAPI du *chemin d'accĂšs*.
* Ceci sera utilisé par la **documentation automatique**.
* Ceci sera également utilisé par les outils de génération automatique de code client.
+* **Sérialiser** les données renvoyées en JSON en utilisant Pydantic, qui est écrit en **Rust**, ce qui sera **beaucoup plus rapide**.
Mais surtout :
/// info | Info
-Pour utiliser `EmailStr`, installez d'abord <a href="https://github.com/JoshData/python-email-validator" class="external-link" target="_blank">`email-validator`</a>.
+Pour utiliser `EmailStr`, installez d'abord [`email-validator`](https://github.com/JoshData/python-email-validator).
-Assurez-vous de créer un [environnement virtuel](../virtual-environments.md){.internal-link target=_blank}, de l'activer, puis de l'installer, par exemple :
+Assurez-vous de créer un [environnement virtuel](../virtual-environments.md), de l'activer, puis de l'installer, par exemple :
```console
$ pip install email-validator
### Renvoyer directement une Response { #return-a-response-directly }
-Le cas le plus courant serait [de renvoyer directement une Response comme expliqué plus loin dans la documentation avancée](../advanced/response-directly.md){.internal-link target=_blank}.
+Le cas le plus courant serait [de renvoyer directement une Response comme expliqué plus loin dans la documentation avancée](../advanced/response-directly.md).
{* ../../docs_src/response_model/tutorial003_02_py310.py hl[8,10:11] *}
* `response_model_exclude_defaults=True`
* `response_model_exclude_none=True`
-comme décrit dans <a href="https://docs.pydantic.dev/1.10/usage/exporting_models/#modeldict" class="external-link" target="_blank">la documentation Pydantic</a> pour `exclude_defaults` et `exclude_none`.
+comme décrit dans [la documentation Pydantic](https://docs.pydantic.dev/1.10/usage/exporting_models/#modeldict) pour `exclude_defaults` et `exclude_none`.
///
/// info
-`status_code` peut aussi recevoir un `IntEnum`, comme le <a href="https://docs.python.org/3/library/http.html#http.HTTPStatus" class="external-link" target="_blank">`http.HTTPStatus`</a> de Python.
+`status_code` peut aussi recevoir un `IntEnum`, comme le [`http.HTTPStatus`](https://docs.python.org/3/library/http.html#http.HTTPStatus) de Python.
///
/// tip | Astuce
-Pour en savoir plus sur chaque code d'état et à quoi il correspond, consultez la <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Status" class="external-link" target="_blank"><abbr title="Mozilla Developer Network - Réseau des développeurs Mozilla">MDN</abbr> documentation about HTTP status codes</a>.
+Pour en savoir plus sur chaque code d'état et à quoi il correspond, consultez la [<abbr title="Mozilla Developer Network - Réseau des développeurs Mozilla">MDN</abbr> documentation sur les codes d'état HTTP](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status).
///
Vous pourriez aussi utiliser `from starlette import status`.
-FastAPI fournit le mĂȘme `starlette.status` que `fastapi.status`, uniquement pour votre commoditĂ© de dĂ©veloppeur. Mais cela vient directement de Starlette.
+**FastAPI** fournit le mĂȘme `starlette.status` que `fastapi.status`, uniquement pour votre commoditĂ© de dĂ©veloppeur. Mais cela vient directement de Starlette.
///
## Modifier la valeur par défaut { #changing-the-default }
-Plus tard, dans le [Guide utilisateur avancé](../advanced/response-change-status-code.md){.internal-link target=_blank}, vous verrez comment renvoyer un code d'état différent de celui par défaut que vous déclarez ici.
+Plus tard, dans le [Guide utilisateur avancé](../advanced/response-change-status-code.md), vous verrez comment renvoyer un code d'état différent de celui par défaut que vous déclarez ici.
Ces informations supplémentaires seront ajoutées telles quelles au **JSON Schema** de sortie pour ce modÚle, et elles seront utilisées dans la documentation de l'API.
-Vous pouvez utiliser l'attribut `model_config` qui accepte un `dict` comme décrit dans <a href="https://docs.pydantic.dev/latest/api/config/" class="external-link" target="_blank">Documentation de Pydantic : Configuration</a>.
+Vous pouvez utiliser l'attribut `model_config` qui accepte un `dict` comme décrit dans [Documentation de Pydantic : Configuration](https://docs.pydantic.dev/latest/api/config/).
Vous pouvez définir `"json_schema_extra"` avec un `dict` contenant toutes les données supplémentaires que vous souhaitez voir apparaßtre dans le JSON Schema généré, y compris `examples`.
OpenAPI a également ajouté les champs `example` et `examples` à d'autres parties de la spécification :
-* <a href="https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#parameter-object" class="external-link" target="_blank">`Parameter Object` (dans la spécification)</a> qui était utilisé par les éléments FastAPI :
+* [`Parameter Object` (dans la spécification)](https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#parameter-object) qui était utilisé par les éléments FastAPI :
* `Path()`
* `Query()`
* `Header()`
* `Cookie()`
-* <a href="https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#media-type-object" class="external-link" target="_blank">`Request Body Object`, dans le champ `content`, sur le `Media Type Object` (dans la spécification)</a> qui était utilisé par les éléments FastAPI :
+* [`Request Body Object`, dans le champ `content`, sur le `Media Type Object` (dans la spécification)](https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#media-type-object) qui était utilisé par les éléments FastAPI :
* `Body()`
* `File()`
* `Form()`
### Le champ `examples` de JSON Schema { #json-schemas-examples-field }
-Ensuite, JSON Schema a ajouté un champ <a href="https://json-schema.org/draft/2019-09/json-schema-validation.html#rfc.section.9.5" class="external-link" target="_blank">`examples`</a> dans une nouvelle version de la spécification.
+Ensuite, JSON Schema a ajouté un champ [`examples`](https://json-schema.org/draft/2019-09/json-schema-validation.html#rfc.section.9.5) dans une nouvelle version de la spécification.
Puis le nouveau OpenAPI 3.1.0 s'est basé sur la derniÚre version (JSON Schema 2020-12) qui incluait ce nouveau champ `examples`.
/// info
-Le package <a href="https://github.com/Kludex/python-multipart" class="external-link" target="_blank">`python-multipart`</a> est installé automatiquement avec **FastAPI** lorsque vous exécutez la commande `pip install "fastapi[standard]"`.
+Le package [`python-multipart`](https://github.com/Kludex/python-multipart) est installé automatiquement avec **FastAPI** lorsque vous exécutez la commande `pip install "fastapi[standard]"`.
Cependant, si vous utilisez la commande `pip install fastapi`, le package `python-multipart` n'est pas inclus par défaut.
-Pour l'installer manuellement, vous devez vous assurer de créer un [environnement virtuel](../../virtual-environments.md){.internal-link target=_blank}, de l'activer, puis de l'installer avec :
+Pour l'installer manuellement, vous devez vous assurer de créer un [environnement virtuel](../../virtual-environments.md), de l'activer, puis de l'installer avec :
```console
$ pip install python-multipart
<div class="termy">
```console
-$ fastapi dev main.py
+$ fastapi dev
<span style="color: green;">INFO</span>: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
```
## VĂ©rifier { #check-it }
-Allez à la documentation interactive à l'adresse : <a href="http://127.0.0.1:8000/docs" class="external-link" target="_blank">http://127.0.0.1:8000/docs</a>.
+Allez à la documentation interactive à l'adresse : [http://127.0.0.1:8000/docs](http://127.0.0.1:8000/docs).
Vous verrez quelque chose comme ceci :
Parce que nous utilisons une URL relative, si votre API se trouvait à `https://example.com/`, alors elle ferait référence à `https://example.com/token`. Mais si votre API se trouvait à `https://example.com/api/v1/`, alors elle ferait référence à `https://example.com/api/v1/token`.
-Utiliser une URL relative est important pour vous assurer que votre application continue de fonctionner mĂȘme dans un cas d'usage avancĂ© comme [DerriĂšre un proxy](../../advanced/behind-a-proxy.md){.internal-link target=_blank}.
+Utiliser une URL relative est important pour vous assurer que votre application continue de fonctionner mĂȘme dans un cas d'usage avancĂ© comme [DerriĂšre un proxy](../../advanced/behind-a-proxy.md).
///
AprÚs une semaine, le jeton aura expiré et l'utilisateur ne sera pas autorisé et devra se reconnecter pour obtenir un nouveau jeton. Et si l'utilisateur (ou un tiers) essayait de modifier le jeton pour changer l'expiration, vous pourriez le détecter, car les signatures ne correspondraient pas.
-Si vous voulez expérimenter avec des jetons JWT et voir comment ils fonctionnent, consultez <a href="https://jwt.io/" class="external-link" target="_blank">https://jwt.io</a>.
+Si vous voulez expérimenter avec des jetons JWT et voir comment ils fonctionnent, consultez [https://jwt.io](https://jwt.io/).
## Installer `PyJWT` { #install-pyjwt }
Nous devons installer `PyJWT` pour générer et vérifier les jetons JWT en Python.
-Assurez-vous de créer un [environnement virtuel](../../virtual-environments.md){.internal-link target=_blank}, de l'activer, puis d'installer `pyjwt` :
+Assurez-vous de créer un [environnement virtuel](../../virtual-environments.md), de l'activer, puis d'installer `pyjwt` :
<div class="termy">
Si vous prévoyez d'utiliser des algorithmes de signature numérique comme RSA ou ECDSA, vous devez installer la dépendance de bibliothÚque de cryptographie `pyjwt[crypto]`.
-Vous pouvez en lire davantage dans la <a href="https://pyjwt.readthedocs.io/en/latest/installation.html" class="external-link" target="_blank">documentation d'installation de PyJWT</a>.
+Vous pouvez en lire davantage dans la [documentation d'installation de PyJWT](https://pyjwt.readthedocs.io/en/latest/installation.html).
///
Mais vous ne pouvez pas convertir le charabia en sens inverse vers le mot de passe.
-### Pourquoi utiliser le hachage de mot de passe { #why-use-password-hashing }
+### Pourquoi utiliser le hachage de mot passe { #why-use-password-hashing }
Si votre base de données est volée, le voleur n'aura pas les mots de passe en clair de vos utilisateurs, seulement les hachages.
L'algorithme recommandé est « Argon2 ».
-Assurez-vous de créer un [environnement virtuel](../../virtual-environments.md){.internal-link target=_blank}, de l'activer, puis d'installer pwdlib avec Argon2 :
+Assurez-vous de créer un [environnement virtuel](../../virtual-environments.md), de l'activer, puis d'installer pwdlib avec Argon2 :
<div class="termy">
## VĂ©rifier { #check-it }
-Lancez le serveur et allez Ă la documentation : <a href="http://127.0.0.1:8000/docs" class="external-link" target="_blank">http://127.0.0.1:8000/docs</a>.
+Lancez le serveur et allez Ă la documentation : [http://127.0.0.1:8000/docs](http://127.0.0.1:8000/docs).
Vous verrez l'interface utilisateur suivante :
## Obtenir `username` et `password` { #get-the-username-and-password }
-Nous allons utiliser les utilitaires de sécurité de **FastAPI** pour obtenir `username` et `password`.
+Nous allons utiliser les utilités de sécurité de **FastAPI** pour obtenir `username` et `password`.
OAuth2 spécifie que lorsqu'on utilise le « password flow » (ce que nous utilisons), le client/utilisateur doit envoyer des champs `username` et `password` en tant que données de formulaire.
## Ăcrire le code pour obtenir `username` et `password` { #code-to-get-the-username-and-password }
-Utilisons maintenant les utilitaires fournis par **FastAPI** pour gérer cela.
+Utilisons maintenant les utilités fournies par **FastAPI** pour gérer cela.
### `OAuth2PasswordRequestForm` { #oauth2passwordrequestform }
/// info
-Pour une explication plus complÚte de `**user_dict`, consultez [la documentation pour **ModÚles supplémentaires**](../extra-models.md#about-user-in-dict){.internal-link target=_blank}.
+Pour une explication plus complÚte de `**user_dict`, consultez [la documentation pour **ModÚles supplémentaires**](../extra-models.md#about-user-in-dict).
///
## Voir en action { #see-it-in-action }
-Ouvrez la documentation interactive : <a href="http://127.0.0.1:8000/docs" class="external-link" target="_blank">http://127.0.0.1:8000/docs</a>.
+Ouvrez la documentation interactive : [http://127.0.0.1:8000/docs](http://127.0.0.1:8000/docs).
### S'authentifier { #authenticate }
**FastAPI** ne vous oblige pas à utiliser une base de données SQL (relationnelle). Mais vous pouvez utiliser **n'importe quelle base de données** que vous voulez.
-Ici, nous allons voir un exemple utilisant <a href="https://sqlmodel.tiangolo.com/" class="external-link" target="_blank">SQLModel</a>.
+Ici, nous allons voir un exemple utilisant [SQLModel](https://sqlmodel.tiangolo.com/).
-**SQLModel** est construit au-dessus de <a href="https://www.sqlalchemy.org/" class="external-link" target="_blank">SQLAlchemy</a> et de Pydantic. Il a Ă©tĂ© crĂ©Ă© par le mĂȘme auteur que **FastAPI** pour ĂȘtre l'accord parfait pour les applications FastAPI qui ont besoin d'utiliser des **bases de donnĂ©es SQL**.
+**SQLModel** est construit au-dessus de [SQLAlchemy](https://www.sqlalchemy.org/) et de Pydantic. Il a Ă©tĂ© crĂ©Ă© par le mĂȘme auteur que **FastAPI** pour ĂȘtre l'accord parfait pour les applications FastAPI qui ont besoin d'utiliser des **bases de donnĂ©es SQL**.
/// tip | Astuce
/// tip | Astuce
-Il existe un générateur de projet officiel avec **FastAPI** et **PostgreSQL**, incluant un frontend et plus d'outils : <a href="https://github.com/fastapi/full-stack-fastapi-template" class="external-link" target="_blank">https://github.com/fastapi/full-stack-fastapi-template</a>
+Il existe un générateur de projet officiel avec **FastAPI** et **PostgreSQL**, incluant un frontend et plus d'outils : [https://github.com/fastapi/full-stack-fastapi-template](https://github.com/fastapi/full-stack-fastapi-template)
///
-Il s'agit d'un tutoriel trÚs simple et court ; si vous souhaitez apprendre sur les bases de données en général, sur SQL, ou des fonctionnalités plus avancées, allez voir la <a href="https://sqlmodel.tiangolo.com/" class="external-link" target="_blank">documentation SQLModel</a>.
+Il s'agit d'un tutoriel trÚs simple et court ; si vous souhaitez apprendre sur les bases de données en général, sur SQL, ou des fonctionnalités plus avancées, allez voir la [documentation SQLModel](https://sqlmodel.tiangolo.com/).
## Installer `SQLModel` { #install-sqlmodel }
-D'abord, assurez-vous de créer votre [environnement virtuel](../virtual-environments.md){.internal-link target=_blank}, de l'activer, puis d'installer `sqlmodel` :
+D'abord, assurez-vous de créer votre [environnement virtuel](../virtual-environments.md), de l'activer, puis d'installer `sqlmodel` :
<div class="termy">
* `Field(primary_key=True)` indique à SQLModel que `id` est la **clé primaire** dans la base SQL (vous pouvez en savoir plus sur les clés primaires SQL dans la documentation SQLModel).
- Remarque : nous utilisons `int | None` pour le champ clé primaire afin qu'en Python nous puissions *créer un objet sans `id`* (`id=None`), en supposant que la base *le génÚre à l'enregistrement*. SQLModel comprend que la base fournira l'`id` et *définit la colonne comme un `INTEGER` non nul* dans le schéma de base. Voir la <a href="https://sqlmodel.tiangolo.com/tutorial/create-db-and-table/#primary-key-id" class="external-link" target="_blank">documentation SQLModel sur les clés primaires</a> pour plus de détails.
+ Remarque : nous utilisons `int | None` pour le champ clé primaire afin qu'en Python nous puissions *créer un objet sans `id`* (`id=None`), en supposant que la base *le génÚre à l'enregistrement*. SQLModel comprend que la base fournira l'`id` et *définit la colonne comme un `INTEGER` non nul* dans le schéma de base. Voir la [documentation SQLModel sur les clés primaires](https://sqlmodel.tiangolo.com/tutorial/create-db-and-table/#primary-key-id) pour plus de détails.
* `Field(index=True)` indique à SQLModel qu'il doit créer un **index SQL** pour cette colonne, ce qui permettra des recherches plus rapides dans la base lors de la lecture de données filtrées par cette colonne.
/// tip | Astuce
-SQLModel aura des utilitaires de migration enveloppant Alembic, mais pour l'instant, vous pouvez utiliser <a href="https://alembic.sqlalchemy.org/en/latest/" class="external-link" target="_blank">Alembic</a> directement.
+SQLModel aura des utilitaires de migration enveloppant Alembic, mais pour l'instant, vous pouvez utiliser [Alembic](https://alembic.sqlalchemy.org/en/latest/) directement.
///
<div class="termy">
```console
-$ fastapi dev main.py
+$ fastapi dev
<span style="color: green;">INFO</span>: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
```
<div class="termy">
```console
-$ fastapi dev main.py
+$ fastapi dev
<span style="color: green;">INFO</span>: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
```
## RĂ©capitulatif { #recap }
-Vous pouvez utiliser <a href="https://sqlmodel.tiangolo.com/" class="external-link" target="_blank">**SQLModel**</a> pour interagir avec une base SQL et simplifier le code avec des *modÚles de données* et des *modÚles de table*.
+Vous pouvez utiliser [**SQLModel**](https://sqlmodel.tiangolo.com/) pour interagir avec une base SQL et simplifier le code avec des *modÚles de données* et des *modÚles de table*.
-Vous pouvez en apprendre beaucoup plus dans la documentation **SQLModel**, il y a un mini <a href="https://sqlmodel.tiangolo.com/tutorial/fastapi/" class="external-link" target="_blank">tutoriel plus long sur l'utilisation de SQLModel avec **FastAPI**</a>. đ
+Vous pouvez en apprendre beaucoup plus dans la documentation **SQLModel**, il y a un mini [tutoriel plus long sur l'utilisation de SQLModel avec **FastAPI**](https://sqlmodel.tiangolo.com/tutorial/fastapi/). đ
Cela diffÚre de l'utilisation d'un `APIRouter`, car une application montée est complÚtement indépendante. L'OpenAPI et les documents de votre application principale n'incluront rien provenant de l'application montée, etc.
-Vous pouvez en lire davantage à ce sujet dans le [Guide utilisateur avancé](../advanced/index.md){.internal-link target=_blank}.
+Vous pouvez en lire davantage à ce sujet dans le [Guide utilisateur avancé](../advanced/index.md).
## DĂ©tails { #details }
## Plus d'informations { #more-info }
-Pour plus de détails et d'options, consultez la <a href="https://www.starlette.dev/staticfiles/" class="external-link" target="_blank">documentation de Starlette sur les fichiers statiques</a>.
+Pour plus de détails et d'options, consultez la [documentation de Starlette sur les fichiers statiques](https://www.starlette.dev/staticfiles/).
# Tester { #testing }
-Grùce à <a href="https://www.starlette.dev/testclient/" class="external-link" target="_blank">Starlette</a>, tester des applications **FastAPI** est simple et agréable.
+Grùce à [Starlette](https://www.starlette.dev/testclient/), tester des applications **FastAPI** est simple et agréable.
-Câest basĂ© sur <a href="https://www.python-httpx.org" class="external-link" target="_blank">HTTPX</a>, dont la conception sâinspire de Requests, ce qui le rend trĂšs familier et intuitif.
+Câest basĂ© sur [HTTPX](https://www.python-httpx.org), dont la conception sâinspire de Requests, ce qui le rend trĂšs familier et intuitif.
-Avec cela, vous pouvez utiliser <a href="https://docs.pytest.org/" class="external-link" target="_blank">pytest</a> directement avec **FastAPI**.
+Avec cela, vous pouvez utiliser [pytest](https://docs.pytest.org/) directement avec **FastAPI**.
## Utiliser `TestClient` { #using-testclient }
/// info
-Pour utiliser `TestClient`, installez dâabord <a href="https://www.python-httpx.org" class="external-link" target="_blank">`httpx`</a>.
+Pour utiliser `TestClient`, installez dâabord [`httpx`](https://www.python-httpx.org).
-Vous devez crĂ©er un [environnement virtuel](../virtual-environments.md){.internal-link target=_blank}, lâactiver, puis y installer le paquet, par exemple :
+Vous devez crĂ©er un [environnement virtuel](../virtual-environments.md), lâactiver, puis y installer le paquet, par exemple :
```console
$ pip install httpx
/// tip | Astuce
-Si vous souhaitez appeler des fonctions `async` dans vos tests en dehors de lâenvoi de requĂȘtes Ă votre application FastAPI (par exemple des fonctions de base de donnĂ©es asynchrones), consultez les [Tests asynchrones](../advanced/async-tests.md){.internal-link target=_blank} dans le tutoriel avancĂ©.
+Si vous souhaitez appeler des fonctions `async` dans vos tests en dehors de lâenvoi de requĂȘtes Ă votre application FastAPI (par exemple des fonctions de base de donnĂ©es asynchrones), consultez les [Tests asynchrones](../advanced/async-tests.md) dans le tutoriel avancĂ©.
///
### Fichier dâapplication **FastAPI** { #fastapi-app-file }
-Supposons que vous ayez une structure de fichiers comme décrit dans [Applications plus grandes](bigger-applications.md){.internal-link target=_blank} :
+Supposons que vous ayez une structure de fichiers comme décrit dans [Applications plus grandes](bigger-applications.md) :
```
.
* Pour passer des en-tĂȘtes, utilisez un `dict` dans le paramĂštre `headers`.
* Pour les cookies, un `dict` dans le paramĂštre `cookies`.
-Pour plus dâinformations sur la maniĂšre de transmettre des donnĂ©es au backend (en utilisant `httpx` ou le `TestClient`), consultez la <a href="https://www.python-httpx.org" class="external-link" target="_blank">documentation HTTPX</a>.
+Pour plus dâinformations sur la maniĂšre de transmettre des donnĂ©es au backend (en utilisant `httpx` ou le `TestClient`), consultez la [documentation HTTPX](https://www.python-httpx.org).
/// info
Notez que le `TestClient` reçoit des donnĂ©es qui peuvent ĂȘtre converties en JSON, pas des modĂšles Pydantic.
-Si vous avez un modĂšle Pydantic dans votre test et que vous souhaitez envoyer ses donnĂ©es Ă lâapplication pendant les tests, vous pouvez utiliser le `jsonable_encoder` dĂ©crit dans [Encodeur compatible JSON](encoder.md){.internal-link target=_blank}.
+Si vous avez un modĂšle Pydantic dans votre test et que vous souhaitez envoyer ses donnĂ©es Ă lâapplication pendant les tests, vous pouvez utiliser le `jsonable_encoder` dĂ©crit dans [Encodeur compatible JSON](encoder.md).
///
AprĂšs cela, vous avez simplement besoin dâinstaller `pytest`.
-Vous devez crĂ©er un [environnement virtuel](../virtual-environments.md){.internal-link target=_blank}, lâactiver, puis y installer le paquet, par exemple :
+Vous devez crĂ©er un [environnement virtuel](../virtual-environments.md), lâactiver, puis y installer le paquet, par exemple :
<div class="termy">
Cette page vous apprendra Ă utiliser les environnements virtuels et Ă comprendre leur fonctionnement.
-Si vous ĂȘtes prĂȘt Ă adopter un outil qui gĂšre tout pour vous (y compris lâinstallation de Python), essayez <a href="https://github.com/astral-sh/uv" class="external-link" target="_blank">uv</a>.
+Si vous ĂȘtes prĂȘt Ă adopter un outil qui gĂšre tout pour vous (y compris lâinstallation de Python), essayez [uv](https://github.com/astral-sh/uv).
///
//// tab | `uv`
-Si vous avez installĂ© <a href="https://github.com/astral-sh/uv" class="external-link" target="_blank">`uv`</a>, vous pouvez lâutiliser pour crĂ©er un environnement virtuel.
+Si vous avez installĂ© [`uv`](https://github.com/astral-sh/uv), vous pouvez lâutiliser pour crĂ©er un environnement virtuel.
<div class="termy">
//// tab | Windows Bash
-Ou si vous utilisez Bash pour Windows (par exemple <a href="https://gitforwindows.org/" class="external-link" target="_blank">Git Bash</a>) :
+Ou si vous utilisez Bash pour Windows (par exemple [Git Bash](https://gitforwindows.org/)) :
<div class="termy">
/// tip | Astuce
-Si vous utilisez <a href="https://github.com/astral-sh/uv" class="external-link" target="_blank">`uv`</a>, vous lâutiliserez pour installer des Ă©lĂ©ments Ă la place de `pip`, vous nâavez donc pas besoin de mettre `pip` Ă niveau. đ
+Si vous utilisez [`uv`](https://github.com/astral-sh/uv), vous lâutiliserez pour installer des Ă©lĂ©ments Ă la place de `pip`, vous nâavez donc pas besoin de mettre `pip` Ă niveau. đ
///
/// tip | Astuce
-Si vous avez utilisĂ© <a href="https://github.com/astral-sh/uv" class="external-link" target="_blank">`uv`</a> pour crĂ©er lâenvironnement virtuel, il lâa dĂ©jĂ fait pour vous, vous pouvez passer cette Ă©tape. đ
+Si vous avez utilisĂ© [`uv`](https://github.com/astral-sh/uv) pour crĂ©er lâenvironnement virtuel, il lâa dĂ©jĂ fait pour vous, vous pouvez passer cette Ă©tape. đ
///
//// tab | `uv`
-Si vous avez <a href="https://github.com/astral-sh/uv" class="external-link" target="_blank">`uv`</a> :
+Si vous avez [`uv`](https://github.com/astral-sh/uv) :
<div class="termy">
//// tab | `uv`
-Si vous avez <a href="https://github.com/astral-sh/uv" class="external-link" target="_blank">`uv`</a> :
+Si vous avez [`uv`](https://github.com/astral-sh/uv) :
<div class="termy">
Par exemple :
-* <a href="https://code.visualstudio.com/docs/python/environments#_select-and-activate-an-environment" class="external-link" target="_blank">VS Code</a>
-* <a href="https://www.jetbrains.com/help/pycharm/creating-virtual-environment.html" class="external-link" target="_blank">PyCharm</a>
+* [VS Code](https://code.visualstudio.com/docs/python/environments#_select-and-activate-an-environment)
+* [PyCharm](https://www.jetbrains.com/help/pycharm/creating-virtual-environment.html)
/// tip | Astuce
## Pourquoi des environnements virtuels { #why-virtual-environments }
-Pour travailler avec FastAPI, vous devez installer <a href="https://www.python.org/" class="external-link" target="_blank">Python</a>.
+Pour travailler avec FastAPI, vous devez installer [Python](https://www.python.org/).
Ensuite, vous devrez installer FastAPI et tout autre package que vous souhaitez utiliser.
</div>
-Cela téléchargera un fichier compressé avec le code de FastAPI, normalement depuis <a href="https://pypi.org/project/fastapi/" class="external-link" target="_blank">PyPI</a>.
+Cela téléchargera un fichier compressé avec le code de FastAPI, normalement depuis [PyPI](https://pypi.org/project/fastapi/).
Il tĂ©lĂ©chargera Ă©galement des fichiers pour dâautres packages dont FastAPI dĂ©pend.
//// tab | Windows Bash
-Ou si vous utilisez Bash pour Windows (par exemple <a href="https://gitforwindows.org/" class="external-link" target="_blank">Git Bash</a>) :
+Ou si vous utilisez Bash pour Windows (par exemple [Git Bash](https://gitforwindows.org/)) :
<div class="termy">
////
-Cette commande crĂ©era ou modifiera certaines [variables dâenvironnement](environment-variables.md){.internal-link target=_blank} qui seront disponibles pour les prochaines commandes.
+Cette commande crĂ©era ou modifiera certaines [variables dâenvironnement](environment-variables.md) qui seront disponibles pour les prochaines commandes.
Lâune de ces variables est la variable `PATH`.
/// tip | Astuce
-Vous pouvez en savoir plus sur la variable dâenvironnement `PATH` dans la section [Variables dâenvironnement](environment-variables.md#path-environment-variable){.internal-link target=_blank}.
+Vous pouvez en savoir plus sur la variable dâenvironnement `PATH` dans la section [Variables dâenvironnement](environment-variables.md#path-environment-variable).
///
Il existe de nombreuses alternatives pour gérer les environnements virtuels, les dépendances de packages (requirements), les projets.
-Lorsque vous ĂȘtes prĂȘt et souhaitez utiliser un outil pour gĂ©rer lâensemble du projet, les dĂ©pendances, les environnements virtuels, etc., je vous suggĂšre dâessayer <a href="https://github.com/astral-sh/uv" class="external-link" target="_blank">uv</a>.
+Lorsque vous ĂȘtes prĂȘt et souhaitez utiliser un outil pour gĂ©rer lâensemble du projet, les dĂ©pendances, les environnements virtuels, etc., je vous suggĂšre dâessayer [uv](https://github.com/astral-sh/uv).
`uv` peut faire beaucoup de choses, il peutâŻ:
projects / thirdparty / fastapi / fastapi.git / commitdiff
