Performance (Fast API)

La performance dans FastAPI fait référence à la capacité de l’application à traiter rapidement les requêtes HTTP, même sous forte charge, tout en utilisant efficacement les ressources serveur.

FastAPI est conçu pour être rapide : il repose sur Starlette et Pydantic, utilise l’asynchronisme natif avec async/await et génère du code optimisé pour la validation des données. Cela en fait un framework particulièrement adapté aux applications nécessitant des réponses rapides et beaucoup de requêtes simultanées.

Comment ça fonctionne dans FastAPI

1. Utilisation de l’asynchronisme

Déclarer les routes avec async def permet à FastAPI de gérer plusieurs requêtes simultanément sans bloquer le serveur.
Les opérations longues (lecture de fichiers, requêtes HTTP, accès base de données) peuvent être exécutées de manière non bloquante.

2. Validation rapide des données

FastAPI utilise Pydantic pour valider et transformer automatiquement les données entrantes.
La validation est compilée et optimisée, ce qui réduit le coût de traitement des données par rapport à une validation manuelle.

3. Optimisation des requêtes et accès aux données

Utiliser des ORM compatibles async, comme Tortoise ORM ou SQLAlchemy async, pour ne pas bloquer l’événement principal.
Limiter les requêtes lourdes et optimiser les jointures et les filtres.

4. Mise en cache et réponses rapides

Stocker les résultats de calculs lourds dans Redis ou Memcached.
Cacher des fragments ou des réponses complètes pour éviter de recalculer inutilement.
Supporter HTTP/2 et compression des réponses via Starlette pour réduire la latence réseau.

5. Scalabilité

Déployer FastAPI derrière un serveur ASGI performant comme Uvicorn ou Hypercorn.
Utiliser plusieurs workers pour répartir la charge entre processus.
Possibilité de mettre en place du load balancing pour les applications à très haute charge.

Exemple conceptuel

URL / endpoint : /predict/
Comportement :
- Le modèle IA est chargé en mémoire au démarrage.
- La route reçoit des données JSON en POST et renvoie une prédiction.
- Les résultats fréquents sont mis en cache pour accélérer la réponse.
- Les requêtes simultanées sont gérées efficacement grâce à l’asynchronisme.

Bonnes pratiques

Déclarer les routes critiques avec async def pour exploiter l’asynchronisme.
Charger les ressources lourdes une seule fois au démarrage.
Optimiser les requêtes base de données et utiliser un ORM async.
Mettre en place un cache mémoire pour les données réutilisées.
Surveiller la performance avec des outils comme Prometheus, New Relic ou Py-roscope.

Pourquoi c’est important

Réduit la latence pour l’utilisateur final.
Permet à l’application de gérer un grand nombre de requêtes simultanées sans surcharger le serveur.
Optimise l’utilisation des ressources et diminue les coûts d’infrastructure.

En résumé

FastAPI est conçu pour être rapide et scalable grâce à l’asynchronisme et à Pydantic.
Les gains majeurs viennent de l’asynchronisme, du cache, et de l’optimisation des requêtes.
Déployer avec Uvicorn/Hypercorn et mettre en cache les résultats critiques améliore considérablement la performance.

Fonctions :

Performance avec Fast API

Exemple de code :

from fastapi import FastAPI
from fastapi.responses import JSONResponse
from functools import lru_cache
import time

app = FastAPI()

# Fonction simulant un calcul coûteux
@lru_cache(maxsize=32)  # Mise en cache des 32 derniers résultats
def expensive_computation(x: int):
    time.sleep(2)  # Simule un traitement long
    return x * x

# Route utilisant la fonction mise en cache
@app.get("/compute/{x}")
def compute(x: int):
    result = expensive_computation(x)
    return JSONResponse(content={"input": x, "result": result})

Explication du code :

from fastapi import FastAPI importe FastAPI pour créer l’application web.
 from fastapi.responses import JSONResponse importe JSONResponse pour renvoyer des réponses JSON personnalisées.
 from functools import lru_cache importe lru_cache, un décorateur permettant de mettre en cache les résultats d’une fonction afin d’améliorer les performances pour les appels répétés.
 import time importe le module time pour simuler un délai dans le calcul, illustrant un traitement coûteux.
Créer l’application FastAPI
 app = FastAPI() crée une instance de l’application FastAPI.
Fonction simulant un calcul coûteux
 @lru_cache(maxsize=32) applique une mise en cache à la fonction expensive_computation. Le paramètre maxsize=32 indique que les 32 derniers résultats calculés seront mémorisés pour accélérer les appels futurs avec les mêmes entrées.
 def expensive_computation(x: int): définit une fonction qui prend un entier x en entrée.
 time.sleep(2) simule un calcul long de 2 secondes.
 return x * x retourne le carré de x.
Route utilisant la fonction mise en cache
 @app.get("/compute/{x}") définit une route GET accessible avec un entier x dans l’URL.
 Exemple : /compute/5.
 result = expensive_computation(x) appelle la fonction mise en cache pour calculer ou récupérer le résultat.
 return JSONResponse(content={"input": x, "result": result}) renvoie le résultat dans un format JSON clair.