-# Exécuter un serveur manuellement - Uvicorn
+# Exécuter un serveur manuellement { #run-a-server-manually }
-La principale chose dont vous avez besoin pour exécuter une application **FastAPI** sur une machine serveur distante est un programme serveur ASGI tel que **Uvicorn**.
+## Utiliser la commande `fastapi run` { #use-the-fastapi-run-command }
-Il existe 3 principales alternatives :
+En bref, utilisez `fastapi run` pour servir votre application FastAPI :
-* <a href="https://www.uvicorn.dev/" class="external-link" target="_blank">Uvicorn</a> : un serveur ASGI haute performance.
-* <a href="https://hypercorn.readthedocs.io/" class="external-link" target="_blank">Hypercorn</a> : un serveur
- ASGI compatible avec HTTP/2 et Trio entre autres fonctionnalités.
-* <a href="https://github.com/django/daphne" class="external-link" target="_blank">Daphne</a> : le serveur ASGI
- conçu pour Django Channels.
-
-## Machine serveur et programme serveur
-
-Il y a un petit détail sur les noms à garder à l'esprit. 💡
-
-Le mot "**serveur**" est couramment utilisé pour désigner à la fois l'ordinateur distant/cloud (la machine physique ou virtuelle) et également le programme qui s'exécute sur cette machine (par exemple, Uvicorn).
+<div class="termy">
-Gardez cela à l'esprit lorsque vous lisez "serveur" en général, cela pourrait faire référence à l'une de ces deux choses.
+```console
+$ <font color="#4E9A06">fastapi</font> run <u style="text-decoration-style:solid">main.py</u>
-Lorsqu'on se réfère à la machine distante, il est courant de l'appeler **serveur**, mais aussi **machine**, **VM** (machine virtuelle), **nœud**. Tout cela fait référence à un type de machine distante, exécutant Linux, en règle générale, sur laquelle vous exécutez des programmes.
+ <span style="background-color:#009485"><font color="#D3D7CF"> FastAPI </font></span> Starting production server 🚀
+ Searching for package file structure from directories
+ with <font color="#3465A4">__init__.py</font> files
+ Importing from <font color="#75507B">/home/user/code/</font><font color="#AD7FA8">awesomeapp</font>
-## Installer le programme serveur
+ <span style="background-color:#007166"><font color="#D3D7CF"> module </font></span> 🐍 main.py
-Vous pouvez installer un serveur compatible ASGI avec :
+ <span style="background-color:#007166"><font color="#D3D7CF"> code </font></span> Importing the FastAPI app object from the module with
+ the following code:
-//// tab | Uvicorn
+ <u style="text-decoration-style:solid">from </u><u style="text-decoration-style:solid"><b>main</b></u><u style="text-decoration-style:solid"> import </u><u style="text-decoration-style:solid"><b>app</b></u>
-* <a href="https://www.uvicorn.dev/" class="external-link" target="_blank">Uvicorn</a>, un serveur ASGI rapide comme l'éclair, basé sur uvloop et httptools.
+ <span style="background-color:#007166"><font color="#D3D7CF"> app </font></span> Using import string: <font color="#3465A4">main:app</font>
-<div class="termy">
+ <span style="background-color:#007166"><font color="#D3D7CF"> server </font></span> Server started at <font color="#729FCF"><u style="text-decoration-style:solid">http://0.0.0.0:8000</u></font>
+ <span style="background-color:#007166"><font color="#D3D7CF"> server </font></span> Documentation at <font color="#729FCF"><u style="text-decoration-style:solid">http://0.0.0.0:8000/docs</u></font>
-```console
-$ pip install "uvicorn[standard]"
+ Logs:
----> 100%
+ <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span> Started server process <b>[</b><font color="#34E2E2"><b>2306215</b></font><b>]</b>
+ <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span> Waiting for application startup.
+ <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span> Application startup complete.
+ <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span> Uvicorn running on <font color="#729FCF"><u style="text-decoration-style:solid">http://0.0.0.0:8000</u></font> <b>(</b>Press CTRL+C
+ to quit<b>)</b>
```
</div>
-/// tip | Astuce
+Cela fonctionnerait pour la plupart des cas. 😎
-En ajoutant `standard`, Uvicorn va installer et utiliser quelques dépendances supplémentaires recommandées.
+Vous pourriez utiliser cette commande par exemple pour démarrer votre application **FastAPI** dans un conteneur, sur un serveur, etc.
-Cela inclut `uvloop`, le remplaçant performant de `asyncio`, qui fournit le gros gain de performance en matière de concurrence.
+## Serveurs ASGI { #asgi-servers }
-///
+Allons un peu plus en détail.
-////
+FastAPI utilise un standard pour construire des frameworks web Python et des serveurs appelé <abbr title="Asynchronous Server Gateway Interface - Interface passerelle serveur asynchrone">ASGI</abbr>. FastAPI est un framework web ASGI.
-//// tab | Hypercorn
+La principale chose dont vous avez besoin pour exécuter une application **FastAPI** (ou toute autre application ASGI) sur une machine serveur distante est un programme serveur ASGI comme **Uvicorn**, c'est celui utilisé par défaut par la commande `fastapi`.
-* <a href="https://github.com/pgjones/hypercorn" class="external-link" target="_blank">Hypercorn</a>, un serveur ASGI également compatible avec HTTP/2.
+Il existe plusieurs alternatives, notamment :
-<div class="termy">
+* <a href="https://www.uvicorn.dev/" class="external-link" target="_blank">Uvicorn</a> : un serveur ASGI haute performance.
+* <a href="https://hypercorn.readthedocs.io/" class="external-link" target="_blank">Hypercorn</a> : un serveur ASGI compatible avec HTTP/2 et Trio entre autres fonctionnalités.
+* <a href="https://github.com/django/daphne" class="external-link" target="_blank">Daphne</a> : le serveur ASGI conçu pour Django Channels.
+* <a href="https://github.com/emmett-framework/granian" class="external-link" target="_blank">Granian</a> : un serveur HTTP Rust pour les applications Python.
+* <a href="https://unit.nginx.org/howto/fastapi/" class="external-link" target="_blank">NGINX Unit</a> : NGINX Unit est un environnement d'exécution d'applications web léger et polyvalent.
-```console
-$ pip install hypercorn
+## Machine serveur et programme serveur { #server-machine-and-server-program }
----> 100%
-```
-
-</div>
+Il y a un petit détail sur les noms à garder à l'esprit. 💡
-...ou tout autre serveur ASGI.
+Le mot « serveur » est couramment utilisé pour désigner à la fois l'ordinateur distant/cloud (la machine physique ou virtuelle) et également le programme qui s'exécute sur cette machine (par exemple, Uvicorn).
-////
+Gardez cela à l'esprit lorsque vous lisez « serveur » en général, cela pourrait faire référence à l'une de ces deux choses.
-## Exécutez le programme serveur
+Lorsqu'on se réfère à la machine distante, il est courant de l'appeler **serveur**, mais aussi **machine**, **VM** (machine virtuelle), **nœud**. Tout cela fait référence à un type de machine distante, exécutant normalement Linux, sur laquelle vous exécutez des programmes.
-Vous pouvez ensuite exécuter votre application de la même manière que vous l'avez fait dans les tutoriels, mais sans l'option `--reload`, par exemple :
+## Installer le programme serveur { #install-the-server-program }
-//// tab | Uvicorn
+Lorsque vous installez FastAPI, il est fourni avec un serveur de production, Uvicorn, et vous pouvez le démarrer avec la commande `fastapi run`.
-<div class="termy">
+Mais vous pouvez également installer un serveur ASGI manuellement.
-```console
-$ uvicorn main:app --host 0.0.0.0 --port 80
+Vous devez créer un [environnement virtuel](../virtual-environments.md){.internal-link target=_blank}, l'activer, puis vous pouvez installer l'application serveur.
-<span style="color: green;">INFO</span>: Uvicorn running on http://0.0.0.0:80 (Press CTRL+C to quit)
-```
-
-</div>
-
-////
-
-//// tab | Hypercorn
+Par exemple, pour installer Uvicorn :
<div class="termy">
```console
-$ hypercorn main:app --bind 0.0.0.0:80
+$ pip install "uvicorn[standard]"
-Running on 0.0.0.0:8080 over http (CTRL + C to quit)
+---> 100%
```
</div>
-////
+Un processus similaire s'appliquerait à tout autre programme de serveur ASGI.
-/// warning
+/// tip | Astuce
-N'oubliez pas de supprimer l'option `--reload` si vous l'utilisiez.
+En ajoutant `standard`, Uvicorn va installer et utiliser quelques dépendances supplémentaires recommandées.
- L'option `--reload` consomme beaucoup plus de ressources, est plus instable, etc.
+Cela inclut `uvloop`, le remplaçant hautes performances de `asyncio`, qui fournit le gros gain de performance en matière de concurrence.
- Cela aide beaucoup pendant le **développement**, mais vous **ne devriez pas** l'utiliser en **production**.
+Lorsque vous installez FastAPI avec quelque chose comme `pip install "fastapi[standard]"`, vous obtenez déjà `uvicorn[standard]` aussi.
///
-## Hypercorn avec Trio
-
-Starlette et **FastAPI** sont basés sur
-<a href="https://anyio.readthedocs.io/en/stable/" class="external-link" target="_blank">AnyIO</a>, qui les rend
-compatibles avec <a href="https://docs.python.org/3/library/asyncio-task.html" class="external-link" target="_blank">asyncio</a>, de la bibliothèque standard Python et
-<a href="https://trio.readthedocs.io/en/stable/" class="external-link" target="_blank">Trio</a>.
-
-Néanmoins, Uvicorn n'est actuellement compatible qu'avec asyncio, et il utilise normalement <a href="https://github.
-com/MagicStack/uvloop" class="external-link" target="_blank">`uvloop`</a >, le remplaçant hautes performances de `asyncio`.
+## Exécuter le programme serveur { #run-the-server-program }
-Mais si vous souhaitez utiliser directement **Trio**, vous pouvez utiliser **Hypercorn** car il le prend en charge. ✨
-
-### Installer Hypercorn avec Trio
-
-Vous devez d'abord installer Hypercorn avec le support Trio :
+Si vous avez installé un serveur ASGI manuellement, vous devrez normalement passer une chaîne d'import dans un format spécial pour qu'il importe votre application FastAPI :
<div class="termy">
```console
-$ pip install "hypercorn[trio]"
----> 100%
+$ uvicorn main:app --host 0.0.0.0 --port 80
+
+<span style="color: green;">INFO</span>: Uvicorn running on http://0.0.0.0:80 (Press CTRL+C to quit)
```
</div>
-### Exécuter avec Trio
+/// note | Remarque
-Ensuite, vous pouvez passer l'option de ligne de commande `--worker-class` avec la valeur `trio` :
+La commande `uvicorn main:app` fait référence à :
-<div class="termy">
+* `main` : le fichier `main.py` (le « module » Python).
+* `app` : l'objet créé dans `main.py` avec la ligne `app = FastAPI()`.
-```console
-$ hypercorn main:app --worker-class trio
+C'est équivalent à :
+
+```Python
+from main import app
```
-</div>
+///
+
+Chaque programme de serveur ASGI alternatif aurait une commande similaire, vous pouvez en lire plus dans leur documentation respective.
+
+/// warning | Alertes
-Et cela démarrera Hypercorn avec votre application en utilisant Trio comme backend.
+Uvicorn et d'autres serveurs prennent en charge une option `--reload` utile pendant le développement.
-Vous pouvez désormais utiliser Trio en interne dans votre application. Ou mieux encore, vous pouvez utiliser AnyIO pour que votre code reste compatible avec Trio et asyncio. 🎉
+L'option `--reload` consomme beaucoup plus de ressources, est plus instable, etc.
+
+Cela aide beaucoup pendant le **développement**, mais vous **ne devriez pas** l'utiliser en **production**.
+
+///
-## Concepts de déploiement
+## Concepts de déploiement { #deployment-concepts }
-Ces exemples lancent le programme serveur (e.g. Uvicorn), démarrant **un seul processus**, sur toutes les IPs (`0.0.
-0.0`) sur un port prédéfini (par example, `80`).
+Ces exemples exécutent le programme serveur (par exemple Uvicorn), en démarrant **un seul processus**, à l'écoute sur toutes les IP (`0.0.0.0`) sur un port prédéfini (par exemple `80`).
-C'est l'idée de base. Mais vous vous préoccuperez probablement de certains concepts supplémentaires, tels que ... :
+C'est l'idée de base. Mais vous voudrez probablement vous occuper de certaines choses supplémentaires, comme :
-* la sécurité - HTTPS
-* l'exécution au démarrage
-* les redémarrages
-* la réplication (le nombre de processus en cours d'exécution)
-* la mémoire
-* les étapes précédant le 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écédant le démarrage
-Je vous en dirai plus sur chacun de ces concepts, sur la façon de les aborder, et donnerai quelques exemples concrets avec des stratégies pour les traiter dans les prochains chapitres. 🚀
+Je vous en dirai plus sur chacun de ces concepts, sur la manière d'y réfléchir, et donnerai quelques exemples concrets avec des stratégies pour les gérer dans les prochains chapitres. 🚀
projects / thirdparty / fastapi / fastapi.git / commitdiff
