Performance (Flask)

La performance dans Flask désigne la capacité de l’application à répondre rapidement et efficacement aux requêtes, même sous forte charge, tout en consommant un minimum de ressources.

Flask, étant un framework minimaliste, n’inclut pas d’optimisations avancées par défaut. Il laisse la liberté au développeur de choisir les bonnes pratiques, architectures et outils pour améliorer la rapidité et la scalabilité.

Cela concerne notamment :

La gestion efficace des requêtes et des ressources.
L’optimisation du code Python et des accès aux données.
L’utilisation d’outils tiers pour améliorer la rapidité de réponse.

Comment ça fonctionne dans Flask

1. Optimisation du code et des requêtes

Éviter les calculs lourds dans la route elle-même :
- Externaliser vers des tâches asynchrones (ex. : Celery, RQ).
Minimiser les requêtes à la base de données :
- Utiliser un ORM comme SQLAlchemy avec des requêtes optimisées (.join(), .selectinload()).
Mettre en cache les résultats répétitifs (via Flask-Caching).

2. Gestion des ressources statiques

Servir les fichiers statiques (images, CSS, JS) via un serveur dédié (Nginx, CDN) plutôt que par Flask.
Activer la compression Gzip/Brotli côté serveur web pour réduire la taille des réponses.

3. Mise en cache et optimisation réseau

Utiliser un cache en mémoire (Redis, Memcached) pour stocker :
- Résultats de calculs lourds.
- Pages ou fragments HTML.
Réduire la taille des réponses JSON (supprimer les champs inutiles).

4. Scalabilité

Ne pas utiliser le serveur de développement intégré en production.
Utiliser un serveur WSGI performant (Gunicorn, uWSGI) avec plusieurs workers.
Activer le load balancing pour répartir la charge entre plusieurs instances.

5. Asynchronisme

Utiliser Flask-SocketIO ou Quart pour gérer les événements temps réel.
Lancer les tâches longues en arrière-plan pour ne pas bloquer la réponse.

Exemple conceptuel

URL / endpoint : /predict/
Comportement :
- Charge un modèle IA en mémoire au démarrage.
- Reçoit des données en POST, calcule une prédiction.
- Mise en cache du résultat pour les entrées identiques.
- Répond en moins de 100 ms grâce au cache Redis.

Bonnes pratiques

Charger en mémoire les ressources réutilisées (modèles IA, fichiers de configuration).
Optimiser les requêtes SQL pour éviter les « N+1 queries ».
Utiliser un serveur HTTP performant avec plusieurs workers.
Mettre en place un système de cache multi-niveaux (RAM → disque → recalcul).
Profilage régulier avec des outils comme flask-profiler ou cProfile.

Pourquoi c’est important

Améliorer la performance réduit la latence perçue par l’utilisateur.
Une application rapide consomme moins de ressources serveur.
Un service performant peut supporter plus d’utilisateurs simultanément sans augmenter les coûts.

En résumé

Flask ne fournit pas d’optimisation native, mais permet une grande flexibilité.
Les gains majeurs viennent de l’optimisation du code, des requêtes et du cache.
L’utilisation d’outils comme Redis, Nginx et Gunicorn est fortement recommandée.

Fonctions :

Performance avec Flask exemple

Exemple de code :

from flask import Flask, jsonify
import time
from functools import lru_cache

app = Flask(__name__)

# 1️⃣ Fonction lente simulée
def long_computation(x):
    time.sleep(2)  # Simule un calcul long
    return x * x

# 2️⃣ Cache simple pour améliorer la performance
@lru_cache(maxsize=32)
def cached_computation(x):
    return long_computation(x)

# 3️⃣ Route qui mesure le temps d'exécution
@app.route("/compute/<int:x>")
def compute(x):
    start_time = time.time()  # Début du chronométrage
    result = cached_computation(x)
    end_time = time.time()  # Fin du chronométrage
    duration = round(end_time - start_time, 2)
    return jsonify({
        "input": x,
        "result": result,
        "execution_time_seconds": duration
    })

# 4️⃣ Route rapide
@app.route("/")
def home():
    return "Bienvenue ! Essayez /compute/10 pour tester la performance."

if __name__ == "__main__":
    app.run(debug=True)

Explication du code :

from flask import Flask, jsonify importe la classe Flask pour créer l’application web et jsonify pour renvoyer des réponses JSON facilement.
 import time importe le module time pour mesurer le temps d’exécution des fonctions.
 from functools import lru_cache importe le décorateur lru_cache pour mettre en cache les résultats de fonctions afin d’améliorer la performance.
 app = Flask(__name__) crée une instance de l’application Flask.
1️⃣ Fonction de calcul long
 def long_computation(x): définit une fonction qui simule un calcul long.
 time.sleep(2) retarde l’exécution de 2 secondes pour simuler un traitement coûteux.
 return x * x retourne le carré de la valeur passée en argument.
2️⃣ Fonction mise en cache
 @lru_cache(maxsize=32) applique un cache pour mémoriser jusqu’à 32 résultats récents.
 La fonction cached_computation(x) renvoie le résultat du calcul, mais si le même argument a déjà été calculé, le résultat est récupéré instantanément depuis le cache, améliorant ainsi la performance.
3️⃣ Route de calcul avec mesure du temps
 @app.route("/compute/<int:x>") définit une route qui prend un entier en paramètre dans l’URL.
 start_time = time.time() démarre le chronomètre avant le calcul.
 result = cached_computation(x) exécute le calcul ou récupère le résultat depuis le cache.
 end_time = time.time() capture l’heure après le calcul.
 duration = round(end_time - start_time, 2) calcule la durée en secondes.
 return jsonify({...}) renvoie un objet JSON contenant l’entrée, le résultat et le temps d’exécution.
4️⃣ Route d’accueil
 @app.route("/") définit la route principale.
 return "Bienvenue ! Essayez /compute/10 pour tester la performance." renvoie un texte simple pour tester l’application.
5️⃣ Lancer l’application Flask
 if __name__ == "__main__": vérifie que le script est exécuté directement.
 app.run(debug=True) démarre le serveur Flask en mode debug, accessible à http://127.0.0.1:5000/. Le mode debug permet le rechargement automatique et l’affichage détaillé des erreurs.