FastAPI¶

🌐 Translation by AI and humans

This translation was made by AI guided by humans. 🤝

It could have mistakes of misunderstanding the original meaning, or looking unnatural, etc. 🤖

You can improve this translation by helping us guide the AI LLM better.

Framework FastAPI, haute performance, facile à apprendre, rapide à coder, prêt pour la production

Documentation : https://fastapi.tiangolo.com/fr

Code Source : https://github.com/fastapi/fastapi

FastAPI est un framework web moderne et rapide (haute performance) pour la création d'API avec Python, basé sur les annotations de type standard de Python.

Les principales fonctionnalités sont :

Rapide : très hautes performances, au niveau de NodeJS et Go (grâce à Starlette et Pydantic). L'un des frameworks Python les plus rapides.
Rapide à coder : augmente la vitesse de développement des fonctionnalités d'environ 200 % à 300 %. *
Moins de bugs : réduit d'environ 40 % les erreurs induites par le développeur. *
Intuitif : excellente compatibilité avec les éditeurs. Autocomplétion partout. Moins de temps passé à déboguer.
Facile : conçu pour être facile à utiliser et à apprendre. Moins de temps passé à lire les documents.
Concis : diminue la duplication de code. Plusieurs fonctionnalités à partir de chaque déclaration de paramètre. Moins de bugs.
Robuste : obtenez un code prêt pour la production. Avec une documentation interactive automatique.
Basé sur des normes : basé sur (et entièrement compatible avec) les standards ouverts pour les APIs : OpenAPI (précédemment connu sous le nom de Swagger) et JSON Schema.

* estimation basée sur des tests d'une équipe de développement interne, construisant des applications de production.

Sponsors¶

Sponsors Or et Argent¶

Autres sponsors

Opinions¶

« [...] J'utilise beaucoup FastAPI ces derniers temps. [...] Je prévois de l'utiliser dans mon équipe pour tous les services de ML chez Microsoft. Certains d'entre eux sont intégrés au cœur de Windows et à certains produits Office. »

Kabir Khan - Microsoft (ref)

« Nous avons adopté la bibliothèque FastAPI pour créer un serveur REST qui peut être interrogé pour obtenir des prédictions. [pour Ludwig] »

Piero Molino, Yaroslav Dudin, et Sai Sumanth Miryala - Uber (ref)

« Netflix est heureux d'annoncer la publication en open source de notre framework d'orchestration de gestion de crise : Dispatch ! [construit avec FastAPI] »

Kevin Glisson, Marc Vilanova, Forest Monsen - Netflix (ref)

« Je suis plus qu'enthousiaste à propos de FastAPI. C'est tellement fun ! »

Brian Okken - Animateur du podcast Python Bytes (ref)

« Honnêtement, ce que vous avez construit a l'air super solide et soigné. À bien des égards, c'est ce que je voulais que Hug soit — c'est vraiment inspirant de voir quelqu'un construire ça. »

Timothy Crosley - Créateur de Hug (ref)

« Si vous cherchez à apprendre un framework moderne pour créer des APIs REST, regardez FastAPI [...] C'est rapide, facile à utiliser et facile à apprendre [...] »

« Nous sommes passés à FastAPI pour nos APIs [...] Je pense que vous l'aimerez [...] »

Ines Montani - Matthew Honnibal - Fondateurs de Explosion AI - Créateurs de spaCy (ref) - (ref)

« Si quelqu'un cherche à construire une API Python de production, je recommande vivement FastAPI. Il est magnifiquement conçu, simple à utiliser et hautement scalable. Il est devenu un composant clé de notre stratégie de développement API-first et alimente de nombreuses automatisations et services tels que notre ingénieur TAC virtuel. »

Deon Pillsbury - Cisco (ref)

Mini documentaire FastAPI¶

Un mini documentaire FastAPI est sorti fin 2025, vous pouvez le regarder en ligne :

Typer, le FastAPI des CLIs¶

Si vous construisez une application CLI à utiliser dans un terminal au lieu d'une API web, regardez Typer.

Typer est le petit frère de FastAPI. Et il est destiné à être le FastAPI des CLIs. ⌨️ 🚀

Prérequis¶

FastAPI repose sur les épaules de géants :

Starlette pour les parties web.
Pydantic pour les parties données.

Installation¶

Créez et activez un environnement virtuel puis installez FastAPI :

$ pip install "fastapi[standard]"

---> 100%

Remarque : Vous devez vous assurer de mettre « fastapi[standard] » entre guillemets pour garantir que cela fonctionne dans tous les terminaux.

Exemple¶

Créer¶

Créez un fichier main.py avec :

from fastapi import FastAPI

app = FastAPI()


@app.get("/")
def read_root():
    return {"Hello": "World"}


@app.get("/items/{item_id}")
def read_item(item_id: int, q: str | None = None):
    return {"item_id": item_id, "q": q}

Ou utilisez async def...

Si votre code utilise async / await, utilisez async def :

from fastapi import FastAPI

app = FastAPI()


@app.get("/")
async def read_root():
    return {"Hello": "World"}


@app.get("/items/{item_id}")
async def read_item(item_id: int, q: str | None = None):
    return {"item_id": item_id, "q": q}

Remarque :

Si vous ne savez pas, consultez la section « Vous êtes pressés ? » à propos de async et await dans la documentation.

Lancer¶

Lancez le serveur avec :

$ fastapi dev main.py

 ╭────────── FastAPI CLI - Development mode ───────────╮
 │                                                     │
 │  Serving at: http://127.0.0.1:8000                  │
 │                                                     │
 │  API docs: http://127.0.0.1:8000/docs               │
 │                                                     │
 │  Running in development mode, for production use:   │
 │                                                     │
 │  fastapi run                                        │
 │                                                     │
 ╰─────────────────────────────────────────────────────╯

INFO:     Will watch for changes in these directories: ['/home/user/code/awesomeapp']
INFO:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
INFO:     Started reloader process [2248755] using WatchFiles
INFO:     Started server process [2248757]
INFO:     Waiting for application startup.
INFO:     Application startup complete.

À propos de la commande fastapi dev main.py...

La commande fastapi dev lit votre fichier main.py, détecte l'application FastAPI qu'il contient et lance un serveur avec Uvicorn.

Par défaut, fastapi dev démarre avec le rechargement automatique activé pour le développement local.

Vous pouvez en savoir plus dans la documentation de la CLI FastAPI.

Vérifier¶

Ouvrez votre navigateur à l'adresse http://127.0.0.1:8000/items/5?q=somequery.

Vous verrez la réponse JSON :

{"item_id": 5, "q": "somequery"}

Vous avez déjà créé une API qui :

Reçoit des requêtes HTTP sur les chemins / et /items/{item_id}.
Les deux chemins acceptent des opérations GET (également connues sous le nom de méthodes HTTP).
Le chemin /items/{item_id} a un paramètre de chemin item_id qui doit être un int.
Le chemin /items/{item_id} a un paramètre de requête optionnel q de type str.

Documentation API interactive¶

Maintenant, rendez-vous sur http://127.0.0.1:8000/docs.

Vous verrez la documentation interactive automatique de l'API (fournie par Swagger UI) :

Swagger UI

Documentation API alternative¶

Et maintenant, rendez-vous sur http://127.0.0.1:8000/redoc.

Vous verrez la documentation alternative automatique (fournie par ReDoc) :

ReDoc

Mettre à niveau l'exemple¶

Modifiez maintenant le fichier main.py pour recevoir un corps depuis une requête PUT.

Déclarez le corps en utilisant les types Python standard, grâce à Pydantic.

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()


class Item(BaseModel):
    name: str
    price: float
    is_offer: bool | None = None


@app.get("/")
def read_root():
    return {"Hello": "World"}


@app.get("/items/{item_id}")
def read_item(item_id: int, q: str | None = None):
    return {"item_id": item_id, "q": q}


@app.put("/items/{item_id}")
def update_item(item_id: int, item: Item):
    return {"item_name": item.name, "item_id": item_id}

Le serveur fastapi dev devrait se recharger automatiquement.

Mettre à niveau la documentation API interactive¶

Maintenant, rendez-vous sur http://127.0.0.1:8000/docs.

La documentation interactive de l'API sera automatiquement mise à jour, y compris le nouveau corps :

Swagger UI

Cliquez sur le bouton « Try it out », il vous permet de renseigner les paramètres et d'interagir directement avec l'API :

Swagger UI interaction

Cliquez ensuite sur le bouton « Execute », l'interface utilisateur communiquera avec votre API, enverra les paramètres, obtiendra les résultats et les affichera à l'écran :

Swagger UI interaction

Mettre à niveau la documentation API alternative¶

Et maintenant, rendez-vous sur http://127.0.0.1:8000/redoc.

La documentation alternative reflètera également le nouveau paramètre de requête et le nouveau corps :

ReDoc

En résumé¶

En résumé, vous déclarez une fois les types de paramètres, le corps, etc. en tant que paramètres de fonction.

Vous faites cela avec les types Python standard modernes.

Vous n'avez pas à apprendre une nouvelle syntaxe, les méthodes ou les classes d'une bibliothèque spécifique, etc.

Juste du Python standard.

Par exemple, pour un int :

item_id: int

ou pour un modèle Item plus complexe :

item: Item

... et avec cette déclaration unique, vous obtenez :

Une assistance dans l'éditeur, notamment :
- l'autocomplétion.
- la vérification des types.
La validation des données :
- des erreurs automatiques et claires lorsque les données ne sont pas valides.
- une validation même pour les objets JSON profondément imbriqués.
Conversion des données d'entrée : venant du réseau vers les données et types Python. Lecture depuis :
- JSON.
- Paramètres de chemin.
- Paramètres de requête.
- Cookies.
- En-têtes.
- Formulaires.
- Fichiers.
Conversion des données de sortie : conversion des données et types Python en données réseau (au format JSON) :
- Conversion des types Python (str, int, float, bool, list, etc).
- Objets datetime.
- Objets UUID.
- Modèles de base de données.
- ... et bien plus.
Documentation API interactive automatique, avec 2 interfaces utilisateur au choix :
- Swagger UI.
- ReDoc.

Pour revenir à l'exemple de code précédent, FastAPI va :

Valider la présence d'un item_id dans le chemin pour les requêtes GET et PUT.
Valider que item_id est de type int pour les requêtes GET et PUT.
- Si ce n'est pas le cas, le client verra une erreur utile et claire.
Vérifier s'il existe un paramètre de requête optionnel nommé q (comme dans http://127.0.0.1:8000/items/foo?q=somequery) pour les requêtes GET.
- Comme le paramètre q est déclaré avec = None, il est optionnel.
- Sans le None, il serait requis (comme l'est le corps dans le cas de PUT).
Pour les requêtes PUT vers /items/{item_id}, lire le corps au format JSON :
- Vérifier qu'il a un attribut obligatoire name qui doit être un str.
- Vérifier qu'il a un attribut obligatoire price qui doit être un float.
- Vérifier qu'il a un attribut optionnel is_offer, qui doit être un bool, s'il est présent.
- Tout cela fonctionne également pour les objets JSON profondément imbriqués.
Convertir automatiquement depuis et vers JSON.
Tout documenter avec OpenAPI, qui peut être utilisé par :
- des systèmes de documentation interactive.
- des systèmes de génération automatique de clients, pour de nombreux langages.
Fournir directement 2 interfaces web de documentation interactive.

Nous n'avons fait qu'effleurer la surface, mais vous avez déjà une idée de la façon dont tout fonctionne.

Essayez de changer la ligne contenant :

    return {"item_name": item.name, "item_id": item_id}

... de :

        ... "item_name": item.name ...

... à :

        ... "item_price": item.price ...

... et voyez comment votre éditeur complète automatiquement les attributs et connaît leurs types :

compatibilité éditeur

Pour un exemple plus complet comprenant plus de fonctionnalités, voir le Tutoriel - Guide utilisateur.

Alerte spoiler : le tutoriel - guide utilisateur inclut :

Déclaration de paramètres provenant d'autres emplacements comme : en-têtes, cookies, champs de formulaire et fichiers.
Comment définir des contraintes de validation comme maximum_length ou regex.
Un système d'injection de dépendances très puissant et facile à utiliser.
Sécurité et authentification, y compris la prise en charge de OAuth2 avec des JWT tokens et l'authentification HTTP Basic.
Des techniques plus avancées (mais tout aussi faciles) pour déclarer des modèles JSON profondément imbriqués (grâce à Pydantic).
Intégration GraphQL avec Strawberry et d'autres bibliothèques.
De nombreuses fonctionnalités supplémentaires (grâce à Starlette) comme :
- WebSockets
- des tests extrêmement faciles basés sur HTTPX et pytest
- CORS
- Cookie Sessions
- ... et plus encore.

Déployer votre application (optionnel)¶

Vous pouvez, si vous le souhaitez, déployer votre application FastAPI sur FastAPI Cloud, allez vous inscrire sur la liste d'attente si ce n'est pas déjà fait. 🚀

Si vous avez déjà un compte FastAPI Cloud (nous vous avons invité depuis la liste d'attente 😉), vous pouvez déployer votre application avec une seule commande.

Avant de déployer, assurez-vous d'être connecté :

$ fastapi login

You are logged in to FastAPI Cloud 🚀

Puis déployez votre application :

$ fastapi deploy

Deploying to FastAPI Cloud...

✅ Deployment successful!

🐔 Ready the chicken! Your app is ready at https://myapp.fastapicloud.dev

C'est tout ! Vous pouvez maintenant accéder à votre application à cette URL. ✨

À propos de FastAPI Cloud¶

FastAPI Cloud est construit par le même auteur et la même équipe derrière FastAPI.

Il simplifie le processus de construction, de déploiement et d'accès à une API avec un effort minimal.

Il apporte la même expérience développeur de la création d'applications avec FastAPI au déploiement dans le cloud. 🎉

FastAPI Cloud est le principal sponsor et financeur des projets open source FastAPI and friends. ✨

Déployer sur d'autres fournisseurs cloud¶

FastAPI est open source et basé sur des standards. Vous pouvez déployer des applications FastAPI sur n'importe quel fournisseur cloud de votre choix.

Suivez les guides de votre fournisseur cloud pour y déployer des applications FastAPI. 🤓

Performance¶

Les benchmarks TechEmpower indépendants montrent que les applications FastAPI s'exécutant sous Uvicorn sont parmi les frameworks Python les plus rapides, juste derrière Starlette et Uvicorn eux-mêmes (utilisés en interne par FastAPI). (*)

Pour en savoir plus, consultez la section Benchmarks.

Dépendances¶

FastAPI dépend de Pydantic et Starlette.

Dépendances `standard`¶

Lorsque vous installez FastAPI avec pip install "fastapi[standard]", il inclut le groupe standard de dépendances optionnelles :

Utilisées par Pydantic :

email-validator - pour la validation des adresses e-mail.

Utilisées par Starlette :

httpx - Obligatoire si vous souhaitez utiliser le TestClient.
jinja2 - Obligatoire si vous souhaitez utiliser la configuration de template par défaut.
python-multipart - Obligatoire si vous souhaitez prendre en charge l’« parsing » de formulaires avec request.form().

Utilisées par FastAPI :

uvicorn - pour le serveur qui charge et sert votre application. Cela inclut uvicorn[standard], qui comprend certaines dépendances (par ex. uvloop) nécessaires pour une haute performance.
fastapi-cli[standard] - pour fournir la commande fastapi.
- Cela inclut fastapi-cloud-cli, qui vous permet de déployer votre application FastAPI sur FastAPI Cloud.

Sans les dépendances `standard`¶

Si vous ne souhaitez pas inclure les dépendances optionnelles standard, vous pouvez installer avec pip install fastapi au lieu de pip install "fastapi[standard]".

Sans `fastapi-cloud-cli`¶

Si vous souhaitez installer FastAPI avec les dépendances standard mais sans fastapi-cloud-cli, vous pouvez installer avec pip install "fastapi[standard-no-fastapi-cloud-cli]".

Dépendances optionnelles supplémentaires¶

Il existe des dépendances supplémentaires que vous pourriez vouloir installer.

Dépendances optionnelles supplémentaires pour Pydantic :

pydantic-settings - pour la gestion des paramètres.
pydantic-extra-types - pour des types supplémentaires à utiliser avec Pydantic.

Dépendances optionnelles supplémentaires pour FastAPI :

orjson - Obligatoire si vous souhaitez utiliser ORJSONResponse.
ujson - Obligatoire si vous souhaitez utiliser UJSONResponse.

Licence¶

Ce projet est soumis aux termes de la licence MIT.