Pour voir exactement ce que vous pouvez inclure dans les réponses, vous pouvez consulter ces sections dans la spécification OpenAPI :
* <ahref="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`.
* <ahref="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`.
@ -20,9 +20,9 @@ Pour y parvenir, importez `JSONResponse` et renvoyez-y directement votre contenu
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`).
///
@ -30,7 +30,7 @@ Assurez-vous qu'il contient les données souhaitées et que les valeurs sont dan
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`.
///
@ -38,4 +38,4 @@ Pour plus de commodités, **FastAPI** fournit les objets `starlette.responses` s
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).
@ -132,7 +132,7 @@ Si vous avez ce cas d’utilisation spécifique avec SQLModel (ou SQLAlchemy), v
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 <ahref="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.
@ -144,7 +144,7 @@ Cela a été modifié dans la version 0.110.0 pour corriger une consommation de
### 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.
@ -16,11 +16,11 @@ Même si votre application **FastAPI** utilise des fonctions `def` normales au l
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 <ahref="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) :
```
.
@ -84,7 +84,7 @@ Notez que nous utilisons async/await avec le nouveau `AsyncClient` — la requê
/// 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 <ahref="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).
///
@ -94,6 +94,6 @@ Comme la fonction de test est désormais asynchrone, vous pouvez également appe
/// 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 <ahref="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")`.
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).
///
@ -228,7 +228,7 @@ Passer le `root_path` à `FastAPI` équivaut à passer l'option de ligne de comm
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 <ahref="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
{
@ -251,9 +251,9 @@ Dans un cas comme celui‑ci (sans préfixe de chemin supprimé), le proxy écou
## 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 <ahref="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/).
<ahref="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.
### Vérifier les réponses { #check-the-responses }
Maintenant, si vous allez à l'URL avec le port pour Uvicorn : <ahref="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
{
@ -345,7 +345,7 @@ Remarquez que même si vous y accédez via `http://127.0.0.1:8000/app`, il affic
///
Et maintenant ouvrez l'URL avec le port pour Traefik, en incluant le préfixe de chemin : <ahref="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 :
@ -370,13 +370,13 @@ Mais voici la partie intéressante. ✨
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 <ahref="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) :
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 <ahref="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) :
@ -429,11 +429,11 @@ Générera un schéma OpenAPI comme :
/// 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 <ahref="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 :
@ -461,6 +461,6 @@ et il ne l'inclura alors pas dans le schéma OpenAPI.
## 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. ✨
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.
Par exemple, si vous cherchez à maximiser la performance, vous pouvez installer et utiliser <ahref="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.
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.
@ -69,7 +53,7 @@ Et il sera documenté comme tel dans OpenAPI.
### 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 à :
@ -77,7 +61,7 @@ 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.
///
@ -91,7 +75,7 @@ Bien sûr, l'en-tête `Content-Type` réel, le code d'état, etc., proviendront
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 }
@ -140,7 +124,7 @@ FastAPI (en fait Starlette) inclura automatiquement un en-tête Content-Length.
### `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 }
@ -154,37 +138,11 @@ Prend des données et renvoie une réponse encodée en `application/json`.
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 <ahref="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 <ahref="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.
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.
///
@ -202,7 +160,7 @@ Ou vous pouvez l'utiliser dans le paramètre `response_class` :
#### 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 <ahref="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.
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.
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).
///
@ -261,13 +213,13 @@ Vous pouvez aussi utiliser le paramètre `response_class` :
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 <ahref="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`.
@ -291,22 +243,30 @@ Maintenant, au lieu de renvoyer :
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.
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 <ahref="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 :
Cela fonctionne grâce à **Pydantic**, qui offre une <ahref="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.
@ -18,7 +18,7 @@ Et bien sûr, cela prend en charge la même chose :
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.
@ -74,7 +74,7 @@ Dans ce cas, vous pouvez simplement remplacer les `dataclasses` standard par `py
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.
@ -88,7 +88,7 @@ Reportez‑vous aux annotations dans le code ci‑dessus pour voir plus de déta
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 <ahref="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/).
@ -38,7 +38,7 @@ Puis, juste après le `yield`, nous déchargeons le modèle. Ce code sera exécu
/// 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. 🤷
@ -150,11 +150,11 @@ Pour cette raison, il est désormais recommandé d'utiliser plutôt le `lifespan
Juste un détail technique pour les nerds curieux. 🤓
Sous le capot, dans la spécification technique ASGI, cela fait partie du <ahref="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 <ahref="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.
@ -162,4 +162,4 @@ Y compris comment gérer l'état de cycle de vie qui peut être utilisé dans d'
## 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).
@ -8,11 +8,11 @@ Dans ce guide, vous apprendrez à générer un **SDK TypeScript** pour votre bac
## Générateurs de SDK open source { #open-source-sdk-generators }
Une option polyvalente est <ahref="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**, <ahref="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 <ahref="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
@ -24,15 +24,15 @@ FastAPI génère automatiquement des spécifications **OpenAPI 3.1**, donc tout
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. 🙇
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 à <ahref="https://heyapi.dev/openapi-ts/get-started"class="external-link"target="_blank">installer `@hey-api/openapi-ts`</a> et lire à propos du <ahref="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.
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.
@ -16,6 +16,6 @@ Et il est possible que, pour votre cas d'utilisation, la solution se trouve dans
## 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.
@ -91,7 +91,7 @@ Il existe de nombreux autres middlewares ASGI.
Pour voir d'autres middlewares disponibles, consultez <ahref="https://www.starlette.dev/middleware/"class="external-link"target="_blank">la documentation des middlewares de Starlette</a> et la <ahref="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).
@ -35,7 +35,7 @@ Cette partie est assez normale, la plupart du code vous est probablement déjà
/// tip | Astuce
Le paramètre de requête `callback_url` utilise un type Pydantic <ahref="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/).
///
@ -66,7 +66,7 @@ Cet exemple n’implémente pas le callback lui-même (qui pourrait être une si
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 <ahref="https://www.python-httpx.org"class="external-link"target="_blank">HTTPX</a> ou <ahref="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/).
///
@ -106,11 +106,11 @@ Il devrait ressembler exactement à un *chemin d'accès* FastAPI normal :
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 <ahref="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 <ahref="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` :
@ -179,7 +179,7 @@ Remarquez que vous ne passez pas le routeur lui-même (`invoices_callback_router
### Vérifier la documentation { #check-the-docs }
Vous pouvez maintenant démarrer votre application et aller sur <ahref="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 :
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
@ -48,7 +48,7 @@ C'est parce qu'on s'attend à ce que vos utilisateurs définissent, par un autre
### Consulter la documentation { #check-the-docs }
Vous pouvez maintenant démarrer votre application et aller sur <ahref="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 :
@ -46,7 +46,7 @@ Pour exclure un chemin d’accès du schéma OpenAPI généré (et donc des syst
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.
@ -60,7 +60,7 @@ Cela définit les métadonnées sur la réponse principale d’un chemin d’acc
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 }
@ -68,7 +68,7 @@ Lorsque vous déclarez un chemin d’accès dans votre application, **FastAPI**
/// note | Détails techniques
Dans la spécification OpenAPI, cela s’appelle l’<ahref="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).
///
@ -82,7 +82,7 @@ Ce schéma OpenAPI spécifique à un chemin d’accès est normalement généré
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*.
@ -20,7 +20,7 @@ Vous pouvez également déclarer le paramètre `Response` dans des dépendances,
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 :
@ -48,4 +48,4 @@ Et comme `Response` peut être utilisé fréquemment pour définir des en-têtes
///
Pour voir tous les paramètres et options disponibles, consultez la <ahref="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 :
@ -40,26 +46,38 @@ Pour ces cas, vous pouvez utiliser le `jsonable_encoder` pour convertir vos donn
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 <ahref="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 :
## 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.
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.
@ -20,7 +20,7 @@ Vous pouvez également déclarer le paramètre `Response` dans des dépendances,
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 :
@ -36,6 +36,6 @@ Et comme `Response` peut être utilisée fréquemment pour définir des en-tête
## En-têtes personnalisés { #custom-headers }
Gardez à l'esprit que des en-têtes propriétaires personnalisés peuvent être ajoutés <ahref="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 <ahref="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 <ahref="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`.
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.
@ -14,6 +14,6 @@ Et il est possible que, pour votre cas d’utilisation, la solution se trouve da
## 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.
@ -60,7 +60,7 @@ Pour OAuth2, ce ne sont que des chaînes.
## 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 :
@ -271,4 +271,4 @@ Mais au final, ils implémentent le même standard OAuth2.
## `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.
@ -8,7 +8,7 @@ C'est pourquoi il est courant de les fournir via des variables d'environnement l
/// 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).
///
@ -20,11 +20,11 @@ Cela signifie que toute valeur lue en Python depuis une variable d'environnement
## Pydantic `Settings` { #pydantic-settings }
Heureusement, Pydantic fournit un excellent utilitaire pour gérer ces paramètres provenant des variables d'environnement avec <ahref="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/).
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` :
<divclass="termy">
@ -100,7 +100,7 @@ Et `items_per_user` conservera sa valeur par défaut de `50`.
## 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 :
@ -112,7 +112,7 @@ Puis l'utiliser dans un fichier `main.py` :
/// 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).
///
@ -172,7 +172,7 @@ Mais un fichier dotenv n'a pas forcément exactement ce nom de fichier.
///
Pydantic prend en charge la lecture depuis ce type de fichiers en utilisant une bibliothèque externe. Vous pouvez en lire davantage ici : <ahref="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
@ -197,7 +197,7 @@ Puis mettre à jour votre `config.py` avec :
/// tip | Astuce
L'attribut `model_config` est utilisé uniquement pour la configuration Pydantic. Vous pouvez en lire davantage ici : <ahref="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/).
///
@ -291,7 +291,7 @@ Dans le cas de notre dépendance `get_settings()`, la fonction ne prend même au
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 <ahref="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).
Ensuite, ouvrez la documentation de la sous‑application à <ahref="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` :
@ -64,4 +64,4 @@ De cette manière, la sous‑application saura utiliser ce préfixe de chemin po
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).
@ -8,7 +8,7 @@ Il existe des utilitaires pour le configurer facilement que vous pouvez utiliser
## 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` :
<divclass="termy">
@ -123,4 +123,4 @@ Et comme vous utilisez `StaticFiles`, ce fichier CSS est servi automatiquement p
## En savoir plus { #more-details }
Pour plus de détails, y compris sur la façon de tester des templates, consultez <ahref="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/).
@ -8,6 +8,6 @@ Pour cela, vous utilisez `TestClient` dans une instruction `with`, en vous conne
/// note | Remarque
Pour plus de détails, consultez la documentation de Starlette sur le <ahref="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).
@ -15,7 +15,7 @@ Mais il existe des situations où vous pouvez avoir besoin d'accéder directemen
## 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 <ahref="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.
@ -45,7 +45,7 @@ De la même façon, vous pouvez déclarer tout autre paramètre normalement, et
## Documentation de `Request` { #request-documentation }
Vous pouvez lire plus de détails sur <ahref="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/).
Vous pouvez utiliser <ahref="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 ») :
<divclass="termy">
@ -64,19 +64,19 @@ Vous pouvez recevoir et envoyer des données binaires, texte et JSON.
## 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 :
<divclass="termy">
```console
$ fastapi dev main.py
$ fastapi dev
<spanstyle="color: green;">INFO</span>: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
```
</div>
Ouvrez votre navigateur à l'adresse <ahref="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 :
@ -115,25 +115,25 @@ Ils fonctionnent de la même manière que pour les autres endpoints/*chemins d'a
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 <ahref="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 :
<divclass="termy">
```console
$ fastapi dev main.py
$ fastapi dev
<spanstyle="color: green;">INFO</span>: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
```
</div>
Ouvrez votre navigateur à l'adresse <ahref="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 :
@ -174,7 +174,7 @@ L'application ci-dessus est un exemple minimal et simple pour montrer comment g
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 <ahref="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).
///
@ -182,5 +182,5 @@ Si vous avez besoin de quelque chose de facile à intégrer avec FastAPI mais pl
Pour en savoir plus sur les options, consultez la documentation de Starlette concernant :
* <ahref="https://www.starlette.dev/websockets/"class="external-link"target="_blank">La classe `WebSocket`</a>.
* <ahref="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.
@ -36,13 +36,13 @@ Désormais, chaque requête sous le chemin `/v1/` sera gérée par l'application
Et le reste sera géré par **FastAPI**.
Si vous l'exécutez et allez à <ahref="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 à <ahref="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 :
@ -6,7 +6,7 @@ Dans la plupart des cas, les principaux fournisseurs cloud proposent des guides
## FastAPI Cloud { #fastapi-cloud }
**<ahref="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.
@ -16,9 +16,9 @@ FastAPI Cloud est le sponsor principal et le financeur des projets open source *
@ -25,7 +25,7 @@ Mais pour l'instant, voyons ces **idées conceptuelles** importantes. Ces concep
## 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**.
@ -190,7 +190,7 @@ Quand vous exécutez **plusieurs processus** du même programme d'API, on les ap
### 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.
@ -243,7 +243,7 @@ Voici quelques combinaisons et stratégies possibles :
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).
///
@ -281,7 +281,7 @@ Voici quelques idées possibles :
/// 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 <ahref="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.
@ -60,16 +60,16 @@ Et le **conteneur** lui-même (par opposition à l'**image de conteneur**) est l
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 <ahref="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 <ahref="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 :
* <ahref="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.
@ -111,7 +111,7 @@ Cela dépendra principalement de l'outil que vous utilisez pour **installer** ce
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 à :
@ -238,7 +238,7 @@ Vous devez vous assurer d'utiliser **toujours** la **forme exec** de l'instructi
#### Utiliser `CMD` - Forme Exec { #use-cmd-exec-form }
L'instruction Docker <ahref="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 :
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 <ahref="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 : <ahref="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 }
Vous devriez pouvoir le vérifier via l'URL de votre conteneur Docker, par exemple : <ahref="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 <ahref="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 :
@ -362,17 +362,17 @@ Vous verrez quelque chose comme :
## Documentation interactive de l'API { #interactive-api-docs }
Vous pouvez maintenant aller sur <ahref="http://192.168.99.100/docs"class="external-link"target="_blank">http://192.168.99.100/docs</a> ou <ahref="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 <ahref="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 <ahref="http://192.168.99.100/redoc"class="external-link"target="_blank">http://192.168.99.100/redoc</a> ou <ahref="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 <ahref="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)) :
@ -413,7 +413,7 @@ Lorsque vous passez le fichier à `fastapi run`, il détectera automatiquement q
## 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.
@ -432,7 +432,7 @@ Passons en revue ces **concepts de déploiement** en termes de conteneurs :
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 <ahref="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
@ -558,7 +558,7 @@ Si vous avez **plusieurs conteneurs**, probablement chacun exécutant un **seul
/// info
Si vous utilisez Kubernetes, ce sera probablement un <ahref="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/).
///
@ -570,7 +570,7 @@ Si vous avez une configuration simple, avec **un seul conteneur** qui démarre e
### Image Docker de base { #base-docker-image }
Il existait une image Docker officielle FastAPI : <ahref="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).
@ -600,7 +600,7 @@ Par exemple :
## Image Docker avec `uv` { #docker-image-with-uv }
Si vous utilisez <ahref="https://github.com/astral-sh/uv"class="external-link"target="_blank">uv</a> pour installer et gérer votre projet, vous pouvez suivre leur <ahref="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/).
Vous pouvez déployer votre application FastAPI sur <ahref="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 }
@ -40,7 +40,7 @@ C’est tout ! Vous pouvez maintenant accéder à votre application à cette URL
## À propos de FastAPI Cloud { #about-fastapi-cloud }
**<ahref="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.
@ -10,7 +10,7 @@ Si vous êtes pressé ou si cela ne vous intéresse pas, continuez avec les sect
///
Pour apprendre les bases du HTTPS, du point de vue d'un utilisateur, consultez <ahref="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 :
@ -28,13 +28,13 @@ Maintenant, du point de vue d'un développeur, voici plusieurs choses à avoir e
* **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 **<ahref="https://en.wikipedia.org/wiki/Server_Name_Indication"class="external-link"target="_blank"><abbrtitle="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 **<ahref="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 :
@ -49,7 +49,7 @@ Avant Let's Encrypt, ces **certificats HTTPS** étaient vendus par des tiers de
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, **<ahref="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.
@ -200,9 +200,9 @@ Ce **proxy** définirait normalement certains en-têtes HTTP à la volée avant
@ -218,7 +218,7 @@ Cela serait utile, par exemple, pour gérer correctement les redirections.
/// 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éé <ahref="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).
@ -52,11 +52,11 @@ La principale chose dont vous avez besoin pour exécuter une application **FastA
Il existe plusieurs alternatives, notamment :
* <ahref="https://www.uvicorn.dev/"class="external-link"target="_blank">Uvicorn</a> : un serveur ASGI haute performance.
* <ahref="https://hypercorn.readthedocs.io/"class="external-link"target="_blank">Hypercorn</a> : un serveur ASGI compatible avec HTTP/2 et Trio entre autres fonctionnalités.
* <ahref="https://github.com/django/daphne"class="external-link"target="_blank">Daphne</a> : le serveur ASGI conçu pour Django Channels.
* <ahref="https://github.com/emmett-framework/granian"class="external-link"target="_blank">Granian</a> : un serveur HTTP Rust pour les applications Python.
* <ahref="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 }
@ -74,7 +74,7 @@ Lorsque vous installez FastAPI, il est fourni avec un serveur de production, Uvi
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.
@ -5,7 +5,7 @@ Reprenons ces concepts de déploiement vus précédemment :
* 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
@ -13,15 +13,15 @@ Jusqu'à présent, avec tous les tutoriels dans les documents, vous avez probabl
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 }
@ -117,23 +117,23 @@ Ici, vous avez vu comment utiliser plusieurs workers pour paralléliser l'exécu
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 <ahref="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.
@ -34,7 +34,7 @@ Si vous utilisez un autre outil pour gérer vos installations, comme `uv`, Poetr
## 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 }
@ -66,7 +66,7 @@ Le « MINOR » est le numéro au milieu, par exemple, dans `0.2.3`, la version M
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.
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, <ahref="https://datatracker.ietf.org/doc/html/rfc7235#section-3.1"class="external-link"target="_blank">RFC 7235</a>, <ahref="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 <ahref="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 :
@ -21,11 +21,11 @@ Si vous voulez sécuriser votre API, il y a plusieurs meilleures approches possi
* 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 :
@ -35,7 +35,7 @@ Ici nous déclarons le paramètre `openapi_url` avec la même valeur par défaut
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 :
Vous pouvez configurer des <ahref="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()`.
@ -50,7 +50,7 @@ Par exemple, pour désactiver `deepLinking`, vous pourriez passer ces paramètre
## Autres paramètres de Swagger UI { #other-swagger-ui-parameters }
Pour voir toutes les autres configurations possibles que vous pouvez utiliser, lisez la <ahref="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/).
@ -54,7 +54,7 @@ Maintenant, pour pouvoir vérifier que tout fonctionne, créez un chemin d'accè
### Tester { #test-it }
Vous devriez maintenant pouvoir aller à vos docs sur <ahref="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 }
@ -93,12 +93,12 @@ Vous pouvez probablement cliquer avec le bouton droit sur chaque lien et choisir
Après cela, votre structure de fichiers pourrait ressembler à :
@ -122,7 +122,7 @@ 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 <ahref="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**.
@ -180,6 +180,6 @@ Maintenant, pour pouvoir vérifier que tout fonctionne, créez un chemin d'accè
### Tester l’UI avec des fichiers statiques { #test-static-files-ui }
Vous devriez maintenant pouvoir couper votre Wi‑Fi, aller à vos docs sur <ahref="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.
@ -18,7 +18,7 @@ Si vous débutez avec **FastAPI**, vous pouvez ignorer cette section.
Voici quelques cas d'utilisation :
* Convertir des corps de requête non JSON en JSON (par exemple <ahref="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.
@ -66,7 +66,7 @@ Le `dict` `scope` et la fonction `receive` font tous deux partie de la spécific
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 <ahref="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/).
@ -37,7 +37,7 @@ Le paramètre `summary` est disponible à partir d'OpenAPI 3.1.0, pris en charge
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 <ahref="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 }
@ -75,6 +75,6 @@ Vous pouvez maintenant remplacer la méthode `.openapi()` par votre nouvelle fon
### Vérifier { #check-it }
Une fois que vous allez sur <ahref="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**) :
# 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).
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).
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).
* Avec <ahref="https://tartiflette.github.io/tartiflette-asgi/"class="external-link"target="_blank">Tartiflette ASGI</a> pour fournir l'intégration ASGI
* Avec <ahref="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**, <ahref="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**.
@ -37,24 +37,24 @@ Voici un petit aperçu de la manière dont vous pouvez intégrer Strawberry avec
Vous pouvez en apprendre davantage sur Strawberry dans la <ahref="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 <ahref="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 à <ahref="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 <ahref="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 <ahref="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 <ahref="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.
@ -8,6 +8,6 @@ Si quelque chose vous paraît intéressant et utile pour votre projet, allez-y e
/// 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.
@ -10,19 +10,19 @@ FastAPI 0.126.0 a supprimé la prise en charge de Pydantic v1, tout en continuan
/// 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 <ahref="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.
@ -30,7 +30,7 @@ Vous pouvez le lire pour mieux comprendre ce qui a changé.
## 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.
@ -38,7 +38,7 @@ De cette façon, vous pouvez effectuer la mise à niveau et vous assurer que tou
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 <ahref="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.
@ -62,7 +62,7 @@ Vous pouvez donc mettre à niveau Pydantic vers la dernière version 2 et modifi
/// 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.
///
@ -108,7 +108,7 @@ graph TB
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 :
# Tester une base de données { #testing-a-database }
Vous pouvez étudier les bases de données, SQL et SQLModel dans <ahref="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 <ahref="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 <ahref="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/). 😎
github-actions[bot]
4 months ago
Yurii Motov