optimiser les performances d’une api python avec fastapi et uvicorn : guide complet

optimiser les performances d’une api python avec fastapi et uvicorn

FastAPI est réputé pour sa rapidité, mais sans réglages appropriés, votre API Python peut devenir un goulet d’étranglement. Dans ce tutoriel, nous verrons comment tirer le meilleur parti de FastAPI et Uvicorn, chiffrer vos gains et atteindre des milliers de requêtes par seconde. Idéal pour un CTO de startup ou un lead dev en quête de performance.

1. préparer l’environnement et mesurer la baseline

1. Installer FastAPI et Uvicorn :

   pip install fastapi uvicorn[standard]

2. Créer une API minimaliste (main.py) :

   from fastapi import FastAPI
   
   app = FastAPI()
   
   @app.get("/items/{id}")
   async def read_item(id: int):
       return {"id": id, "value": "coucou"}

3. Démarrer Uvicorn en mode par défaut :

   uvicorn main:app --host 0.0.0.0 --port 8000

4. Benchmark initial avec hey (1000 requêtes, 50 concurrents) :

   hey -n 1000 -c 50 http://localhost:8000/items/1

   Résultat typique : ~2000 RPS, latence moyenne ~25 ms.

2. augmenter le nombre de workers et ajuster le loop

Uvicorn propose un paramètre --workers pour lancer plusieurs processus :

uvicorn main:app --workers 4 --host 0.0.0.0 --port 8000

• 4 workers → ~4× plus de throughput, mais attention à la mémoire
• Option --loop uvloop (installé via pip install uvloop) pour un scheduler plus rapide :

uvicorn main:app --workers 4 --loop uvloop

Re-benchmarquez : vous devriez atteindre 6000–8000 RPS selon votre machine.

3. profilage et identification des points chauds

Intégrez Prometheus et Grafana ou plus léger py-spy pour détecter :

• fonctions lentes (ex. accès DB non optimisé)
• bloquages CPU ou I/O

pip install py-spy
py-spy top --pid $(pgrep -f "uvicorn main:app")

4. bonnes pratiques de code et sécurité

• éviter les fonctions synchrone lourdes dans un endpoint async ;
• utiliser pydantic pour valider les données et réduire les erreurs runtime ;
• garder le max_header_size et les timeouts Uvicorn/Gunicorn serrés pour limiter les attaques Slowloris.

Exemple de config Gunicorn + Uvicorn Workers dans gunicorn.conf.py

workers = 4
worker_class = "uvicorn.workers.UvicornWorker"
timeout = 30
limit_request_fields = 100

5. conteneurisation et orchestration

Pour passer en production : Dockerisez votre API et dimensionnez vos pods Kubernetes ou ECS.

# Dockerfile
FROM python:3.11-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
CMD ["uvicorn", "main:app", "--workers", "4", "--host", "0.0.0.0", "--port", "8000"]

Déployez sur votre cluster (EKS, GKE, AKS) ou en Fargate.

6. cas réel et retours d’expérience

Chez un client SaaS B2B, nous sommes passés de 1800 à 7200 RPS en production, tout en maintenant une latence sous 15 ms. Les coûts sur ECS ont diminué de 30 %, rendant l’API plus résiliente et économe.

bonnes pratiques résumé

• benchmark avant/après pour mesurer l’impact
• choisir le nombre de workers en fonction de la CPU/RAM
• profilage régulier (py-spy, Prometheus)
• sécuriser les headers et timeouts
• mettre en place un CI/CD (voir notre article sur déploiement d’applications web)

conclusion

Optimiser les performances d’une API Python avec FastAPI et Uvicorn passe par des réglages ciblés (workers, loop, profiling) et une conteneurisation adaptée. En suivant ces étapes, vous maximisez la scalabilité et réduisez vos coûts cloud tout en garantissant une expérience utilisateur fluide.

Envie d’accélérer votre projet ? Contactez notre équipe pour un accompagnement sur mesure.