Introduction à FastAPI

25 octobre 2025

Résumé
FastAPI est un framework web moderne et performant pour Python, conçu pour
créer des APIs RESTful rapides, fiables et facilement documentées. Basé sur Starlette
pour la gestion asynchrone et Pydantic pour la validation des données, il combine
la simplicité de Flask avec la puissance de la typage statique et de l’asynchronisme.
Ce document présente une introduction pratique à FastAPI : installation, endpoints,
validation, dépendances, sécurité, et déploiement.

Table des matières

1 Introduction 3
1.1 Objectif . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.2 Caractéristiques principales . . . . . . . . . . . . . . . . . . . . . . . . . . 3

2 Installation et exécution 3

3 Création d’une première API 3

4 Validation et sérialisation (Pydantic) 4

5 Asynchronisme 4

6 Paramètres de requête et de chemin 4

7 Gestion des dépendances 5

8 Sécurité et authentification 5

9 Gestion des erreurs 5

10 Middleware et événements 6

11 Tests automatisés 6

12 Déploiement 6
12.1 Production avec Uvicorn/Gunicorn . . . . . . . . . . . . . . . . . . . . . . 6
12.2 Dockerisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

13 Documentation automatique 7

1
14 Bonnes pratiques 7

15 Conclusion 7

2
 1 Introduction
1.1 Objectif
FastAPI vise à simplifier la création d’APIs performantes tout en assurant une va-
lidation stricte et une documentation automatique. Son nom vient de ses deux qualités
principales :
— Fast : basé sur uvicorn et Starlette, il est asynchrone et très rapide.
— API : conçu dès le départ pour exposer des services RESTful et compatibles Ope-
nAPI/Swagger.

1.2 Caractéristiques principales

— Typage Python complet et autocomplétion IDE.
— Documentation automatique Swagger et ReDoc.
— Support asynchrone avec async/await.
— Validation et sérialisation automatiques (Pydantic).
— Injection de dépendances intégrée.

2 Installation et exécution

Listing 1 – Installation de FastAPI et du serveur Uvicorn

1 # Installation de FastAPI et du serveur ASGI uvicorn
2 pip install fastapi uvicorn
3
4 # Lancer un serveur de d v e l o p p e m e n t
5 uvicorn main : app -- reload

L’argument –reload redémarre automatiquement le serveur après chaque modification

du code (utile en développement).

3 Création d’une première API

Listing 2 – Hello World avec FastAPI

1 from fastapi import FastAPI
2
3 app = FastAPI ()
4
5 @app . get ( " / " )
6 def read_root () :
7 return { " message " : " Bienvenue sur FastAPI ! " }
8
9 @app . get ( " / items /{ item_id } " )
10 def read_item ( item_id : int , q : str | None = None ) :
11 return { " item_id " : item_id , " query " : q }

3
 Accès via :
— [Link] → Interface Swagger interactive.
— [Link] → Documentation ReDoc.

4 Validation et sérialisation (Pydantic)

Listing 3 – Modèle de données Pydantic

1 from pydantic import BaseModel
2
3 class Item ( BaseModel ) :
4 name : str
5 description : str | None = None
6 price : float
7 tax : float | None = None
8
9 @app . post ( " / items / " )
10 def create_item ( item : Item ) :
11 total = item . price + ( item . tax or 0)
12 return { " item " : item , " total " : total }

FastAPI valide automatiquement le corps JSON selon le schéma défini et renvoie des
erreurs claires en cas d’incohérence.

5 Asynchronisme

Listing 4 – Endpoint asynchrone

1 from fastapi import FastAPI
2 import asyncio
3
4 app = FastAPI ()
5
6 @app . get ( " / wait " )
7 async def simulate_io () :
8 await asyncio . sleep (2)
9 return { " status " : " done " }

Les fonctions déclarées avec async def permettent de gérer de multiples requêtes concur-
rentes sans bloquer le serveur.

6 Paramètres de requête et de chemin

Listing 5 – Exemples de paramètres

1 from fastapi import Path , Query
2
3 @app . get ( " / users /{ user_id } " )
4 def get_user (

4
5 user_id : int = Path (... , ge =1) ,
6 active : bool = Query ( True , description = " Filtrer les
utilisateurs actifs " )
7 ):
8 return { " user_id " : user_id , " active " : active }

7 Gestion des dépendances

Listing 6 – Exemple de dépendance

1 from fastapi import Depends
2
3 def get_db () :
4 db = { " connected " : True }
5 try :
6 yield db
7 finally :
8 db [ " connected " ] = False
9
10 @app . get ( " / dbstatus " )
11 def read_db_status ( db = Depends ( get_db ) ) :
12 return { " db_connected " : db [ " connected " ]}

Les dépendances permettent d’injecter facilement des connexions, paramètres ou contrôles

communs à plusieurs routes.

8 Sécurité et authentification

Listing 7 – Authentification basique avec OAuth2PasswordBearer

1 from fastapi . security import OAuth2PasswordBearer
2 from fastapi import Depends , HTTPException , status
3
4 oauth2_scheme = OAuth2PasswordBearer ( tokenUrl = " token " )
5
6 @app . get ( " / profile " )
7 def read_profile ( token : str = Depends ( oauth2_scheme ) ) :
8 if token != " mon_token_secret " :
9 raise HTTPException ( status_code = status .
HTTP_401_UNAUTHORIZED ,
10 detail = " Token invalide " )
11 return { " user " : " admin " , " roles " : [ " admin " ]}

FastAPI gère les schémas OAuth2, JWT, API Keys et Basic Auth via ses utilitaires
intégrés.

9 Gestion des erreurs

5
 Listing 8 – Gestion d’erreurs personnalisées
1 from fastapi import HTTPException
2
3 @app . get ( " / divide /{ a }/{ b } " )
4 def divide ( a : int , b : int ) :
5 if b == 0:
6 raise HTTPException ( status_code =400 , detail = " Division par
z r o ")
7 return { " result " : a / b }

10 Middleware et événements

Listing 9 – Middleware de logging simple

1 from fastapi import Request
2
3 @app . middleware ( " http " )
4 async def log_requests ( request : Request , call_next ) :
5 print ( f " --> { request . method } { request . url } " )
6 response = await call_next ( request )
7 print ( f " <-- { response . status_code } " )
8 return response

Les événements de démarrage/arrêt (@[Link] vent(”startup”))permettentd′ initialiserdesressources(D

11 Tests automatisés

Listing 10 – Tests avec TestClient

1 from fastapi . testclient import TestClient
2
3 client = TestClient ( app )
4
5 def test_root () :
6 r = client . get ( " / " )
7 assert r . status_code == 200
8 assert r . json () == { " message " : " Bienvenue sur FastAPI ! " }

12 Déploiement
12.1 Production avec Uvicorn/Gunicorn

Listing 11 – Commande de déploiement

1 uvicorn main : app -- host [Link] -- port 8000 -- workers 4

6
12.2 Dockerisation

Listing 12 – Dockerfile pour FastAPI

FROM python :3.12 - slim
WORKDIR / app
COPY requirements . txt .
RUN pip install -r requirements . txt
COPY . .
EXPOSE 8000
CMD [" uvicorn " , " main : app " , " - - host " , "[Link]" , " - - port " , "8000"]

13 Documentation automatique
FastAPI génère automatiquement deux interfaces :
— Swagger UI : [Link]
— ReDoc : [Link]
Elles décrivent tous les endpoints, leurs modèles d’entrée/sortie et leurs
statuts HTTP.

14 Bonnes pratiques
— Structurer le projet en modules : routers/, schemas/, models/.
— Séparer les schémas Pydantic et les modèles ORM.
— Utiliser async def partout où c’est possible.
— Activer le typage complet et les tests unitaires.
— Versionner l’API : /api/v1/, /api/v2/.

15 Conclusion
FastAPI combine performance, simplicité et robustesse. Grâce à son approche
basée sur les types et Pydantic, il réduit drastiquement les bugs liés aux
données. C’est aujourd’hui un des frameworks Python les plus prisés pour le
développement d’APIs modernes et scalables.

Références :
— FastAPI Documentation : [Link]
— Pydantic Documentation : [Link]
— Starlette Documentation : [Link]