Faire tenir la charge à une application web, dans le bon ordre

Par Hamza Mechtaly · · 3 min de lecture

Mesurer, rendre l’application sans état, soulager la base, passer à l’asynchrone : l’ordre dans lequel j’attaque un problème de montée en charge.

Scalabilité d’une application web

Quand une application ralentit sous la charge, le premier réflexe est souvent d’ajouter des serveurs. Parfois ça marche. Souvent, ça déplace juste le problème vers la base de données, qui tombe un peu plus tard et un peu plus fort. J’attaque ces sujets dans un ordre assez constant.

1. Mesurer avant de toucher à quoi que ce soit

Sans mesure, on optimise au hasard. Avant toute modification, je veux savoir :

  • quelles requêtes sont lentes, et à quel percentile (le 95e ou le 99e, pas la moyenne, qui cache tout) ;
  • où passe le temps : application, base de données, appel à un service externe ;
  • à partir de quelle charge ça se dégrade.

Un outil d’APM (Dynatrace, Elastic APM, ou OpenTelemetry avec Grafana) répond aux deux premières questions. Un test de charge avec Gatling, k6 ou JMeter répond à la troisième. Dans une bonne partie des cas, on découvre une poignée de requêtes SQL sans index ou une boucle qui interroge la base cent fois par page. C’est corrigé en une journée, sans un serveur de plus.

2. Rendre l’application sans état

Pour ajouter des instances derrière un répartiteur de charge, il faut que n’importe quelle instance puisse traiter n’importe quelle requête. Ça veut dire :

  • pas de session HTTP stockée en mémoire du serveur : on la met dans Redis, ou on passe à un jeton ;
  • pas de fichiers écrits sur le disque local : ils vont dans un stockage partagé ou objet ;
  • pas de tâche planifiée qui tourne sur chaque instance en même temps : un verrou distribué (ShedLock, par exemple) ou un ordonnanceur dédié.

Une fois l’application sans état, la montée en charge horizontale devient une simple affaire de nombre d’instances, que Kubernetes ou OpenShift peut ajuster tout seul avec un HorizontalPodAutoscaler.

3. Soulager la base de données

C’est presque toujours elle le vrai goulot. Par ordre d’effort croissant :

  1. les index et les requêtes, encore et toujours ;
  2. le pool de connexions bien dimensionné : plus de connexions ne veut pas dire plus de débit, et un pool trop grand peut écrouler la base ;
  3. un cache pour les données lues souvent et modifiées rarement (référentiels, paramètres, catalogue) ;
  4. des réplicas en lecture pour les écrans de consultation et les exports ;
  5. le partitionnement, en dernier recours, quand une table devient vraiment énorme.

Sur le cache, une règle : décider dès le départ comment il est invalidé. Un cache qui sert des données fausses fait plus de dégâts qu’une page lente.

4. Sortir le lent du chemin de la requête

Générer un PDF, envoyer un e-mail, appeler un partenaire lent : rien de tout ça n’a besoin de se faire pendant que l’utilisateur attend. On dépose une tâche dans une file (RabbitMQ, Kafka, ou une simple table de travaux), on répond tout de suite, et des travailleurs traitent la file à leur rythme. L’application reste rapide même quand le partenaire ne l’est pas, et un pic de charge s’étale dans le temps au lieu de tout faire tomber.

5. Prévoir l’échec

À grande échelle, quelque chose est toujours en panne quelque part. Quelques protections évitent qu’une panne locale ne devienne générale :

  • des délais d’attente sur tous les appels sortants, sans exception ;
  • un disjoncteur (Resilience4j en Java) qui arrête d’appeler un service en échec ;
  • une dégradation acceptable : afficher la page sans le bloc de recommandations plutôt qu’une erreur 500.

Et après ?

Ce n’est qu’après tout ça que je parle de découper l’application ou de changer d’architecture. La plupart des applications que j’ai vues tenir des charges importantes ne sont pas exotiques : elles sont mesurées, sans état, avec une base bien traitée et le travail lent mis de côté. Ce n’est pas spectaculaire, mais ça fonctionne.

À lire aussi