C’est précisément ce que mesure la scalabilité : la capacité d’un système informatique à absorber une hausse de charge (plus d’utilisateurs, de requêtes ou de données) en recevant des ressources supplémentaires, sans que ses performances se dégradent en proportion. On parle aussi d’extensibilité ou de passage à l’échelle. Elle se joue à deux étages : l’infrastructure fournit les ressources, l’application doit savoir s’en servir. Une plateforme qui scale automatiquement ne rend donc pas, à elle seule, une application scalable.
Qu’est-ce que la scalabilité en informatique ?
Le terme vient de l’anglais scalability, formé sur to scale : changer d’échelle. Concrètement, un système est scalable quand vous pouvez multiplier sa capacité en lui ajoutant des ressources, et que le gain obtenu reste proche de l’effort consenti.
Prenez une API qui plafonne à 500 requêtes par seconde sur deux serveurs. Avec quatre serveurs, elle devrait approcher les 1 000. Si elle stagne à 600, c’est qu’un goulot d’étranglement se cache ailleurs : une base de données, un verrou, un fichier partagé. La scalabilité se mesure donc sous charge, et toujours par rapport à une ressource précise.
Le mot circule aussi dans le vocabulaire de l’entreprise, où un modèle « scalable » augmente ses revenus plus vite que ses coûts. Les deux sens se rejoignent souvent, car un service en ligne n’accueille de nouveaux clients que si son infrastructure suit. Et pour la faire suivre, on en revient aux deux remèdes du départ.
Scalabilité horizontale et verticale : deux façons de monter en charge
Ces deux remèdes portent un nom : la scalabilité verticale et la scalabilité horizontale.
La scalabilité verticale (scale up) donne plus de ressources à une même machine : plus de vCPU, plus de mémoire. Elle ne demande rien à l’application, qui continue de tourner en un seul exemplaire. Sa limite est donc physique : la plus grande taille d’instance proposée par votre hébergeur fixe le plafond.
La scalabilité horizontale (scale out) ajoute au contraire des instances identiques de l’application, réparties derrière un répartiteur de charge (load balancer). Le plafond recule beaucoup plus loin, mais la contrepartie se paie dans le code : chaque instance doit pouvoir traiter n’importe quelle requête, ce qui impose de stocker l’état (sessions, fichiers, caches) hors de l’instance.
| Critère | Scalabilité verticale (scale up) | Scalabilité horizontale (scale out) |
|---|---|---|
| Mécanisme | Une instance plus grande remplace la précédente | Des instances identiques s’ajoutent en parallèle |
| Plafond | La plus grande taille d’instance disponible | Le nombre maximal d’instances, et surtout la capacité des dépendances |
| Exigence côté application | Aucune | Pas d’état local : l’application doit pouvoir tourner en plusieurs exemplaires |
| Effet sur la base de données | Autant de connexions, mais davantage de requêtes à traiter, sauf si un cache les absorbe | Un pool de connexions de plus par instance |
| Disponibilité | Une seule instance reste un point unique de défaillance | Si une instance tombe, les autres continuent de répondre |
| Cas typique | Logiciel qui supporte mal la redondance, application monolithique | API, application web sans état, workers |
Comment choisir entre scalabilité horizontale et verticale
Entre les deux, la nature de l’application décide, et deux questions aident à trancher.
D’abord, votre application peut-elle tourner en plusieurs exemplaires ? Certains logiciels supportent mal la redondance, parce qu’ils synchronisent un état interne ou écrivent sur un disque local. Ceux-là scalent verticalement, par construction. Si votre application fonctionne en multi-instance, l’horizontal reste en général le levier le plus simple : vous ajoutez des workers qui travaillent en parallèle.
Ensuite, vos dépendances suivront-elles ? Chaque instance supplémentaire ouvre ses propres connexions à la base de données. Dix instances avec un pool de vingt connexions chacune représentent ainsi deux cents connexions simultanées pour la base. Si elle n’est pas dimensionnée pour, ajouter des instances déplace le goulot sans le résoudre, et l’on retrouve l’API bloquée à 600 requêtes par seconde.
Agrandir ou multiplier les machines apporte de la capacité. Encore faut-il ne pas la confondre avec deux notions voisines.
Scalabilité, élasticité, haute disponibilité : trois notions distinctes
Ces trois termes se croisent dans les discussions d’architecture et se confondent souvent, parce qu’ils parlent tous de ressources.
La scalabilité dit si le système peut absorber plus de charge quand on lui donne plus de ressources.
L’élasticité ajoute le mouvement : les ressources suivent la demande, à la hausse comme à la baisse, sans intervention humaine. C’est l’auto-scaling qui produit ce mouvement. Une application peut donc être scalable sans être élastique, si chaque ajout de ressources passe par un humain.
La haute disponibilité répond, elle, à une autre question : le service tient-il quand un composant tombe ? Elle repose sur la redondance. Deux instances déployées pour la disponibilité n’ajoutent pas forcément de capacité utile, et une seule instance, même de grande taille, reste un point unique de défaillance.
L’élasticité est précisément ce qu’on attend de l’auto-scaling. Elle relève du premier étage, celui de l’infrastructure.
Auto-scaling : comment une plateforme décide de scaler
L’auto-scaling (aussi écrit autoscaling), ou mise à l’échelle automatique, ajuste les ressources d’une application sans intervention humaine, à partir de métriques observées. Pour cela, un autoscaler doit savoir quoi surveiller et à partir de quel seuil réagir. Les bornes entre lesquelles il agit, elles, sont fixées par vous.
Des métriques qui ne présentent pas le même danger
Un autoscaler peut surveiller deux types de signaux. Les uns mesurent des ressources : la mémoire ou le disque disponibles, ou encore le CPU, dont la charge est en réalité un coût prélevé sur une ressource. Les autres sont des indicateurs de performance ou de santé de l’application, comme le nombre de requêtes, de connexions ou le temps de réponse. Les autoscalers se distinguent par les signaux qu’ils suivent et par la façon dont ils y réagissent.
Chez Clever Cloud, notre autoscaler surveille le CPU et la mémoire, et ne les traite pas de la même façon. Quand l’activité CPU reste élevée de façon soutenue, sur une fenêtre de l’ordre d’une à deux minutes, il déclenche une montée en charge. Quand la mémoire libre passe sous un seuil, il réagit immédiatement, sans attendre que la situation se confirme. Cette différence tient à la gravité des deux situations. Un CPU saturé ralentit l’application ou lui fait refuser de nouvelles connexions : vos utilisateurs le subissent, mais l’application se rétablit d’elle-même quand la charge retombe. Un manque de mémoire, lui, peut tuer le processus, voire corrompre des données, et coûte bien plus cher à rattraper.
Pour la descente, l’autoscaler suit la logique inverse : il attend que la charge CPU reste basse pendant une fenêtre plus longue avant de retirer des ressources. Kubernetes applique le même principe à son Horizontal Pod Autoscaler : par défaut, il monte sans délai et attend cinq minutes avant de réduire le nombre de réplicas. Monter vite et descendre lentement évite ainsi qu’une application oscille entre deux tailles au gré de pics passagers.
Les bornes : deux réglages, un plafond de dépense
Ces seuils, vous ne les réglez pas : vous fixez les bornes entre lesquelles nous agissons. Chaque instance, que nous appelons Scaler, est une machine virtuelle indépendante, définie par son CPU et sa mémoire. Pour le scaling horizontal, vous choisissez un nombre minimal et maximal de Scalers, jusqu’à 40. Pour le scaling vertical, une taille minimale et maximale, de pico à 3XL (16 vCPU et 32 Gio de mémoire). Le réglage se fait dans la console ou en ligne de commande :
clever scale --min-instances 2 --max-instances 6
clever scale --min-flavor S --max-flavor XL
Quand les deux scalings sont réglés, la plateforme privilégie le vertical : elle agrandit d’abord les Scalers en place, puis en ajoute une fois la taille maximale atteinte. Avec des bornes de S à L et de 2 à 4 Scalers, la montée suit ainsi l’ordre 2-S => 2-M => 2-L => 3-L => 4-L, selon la règle décrite dans notre documentation.
Ces bornes servent aussi de plafond budgétaire. La facturation suit la taille des instances et leur durée d’exécution, à la seconde : la borne maximale fixe donc la dépense la plus haute possible pour l’application. Attention enfin aux plus petites tailles : pico et nano tournent avec une priorité CPU réduite sur l’hôte. Si votre application est sensible à la latence, choisissez une taille minimale au-dessus.
Ce qui se passe pendant un scaling : pas de build, un boot, une bascule
Une fois la décision prise, ajouter un Scaler ne relance pas le build. Nous réutilisons le cache de build et démarrons une machine virtuelle de la taille voulue, ce qui prend quelques secondes. S’y ajoute le temps de démarrage propre à votre application : une JVM qui charge un gros contexte met plus longtemps qu’un binaire Go.
Le scaling vertical, lui, remplace une instance par une autre et suit le même chemin qu’un redéploiement. La nouvelle instance démarre, et nous vérifions qu’elle répond : sur le port 8080, puis sur les chemins déclarés dans CC_HEALTH_CHECK_PATH si vous en avez configuré. Ensuite seulement, Sōzu, notre load balancer écrit en Rust, lui envoie le nouveau trafic. Les connexions encore ouvertes sur l’ancienne instance disposent d’un délai pour se terminer, puis l’ancienne instance s’éteint. Pendant ce recouvrement, deux instances tournent, mais une seule reçoit les nouvelles requêtes.
Ce recouvrement est le comportement par défaut, porté par l’option « Déploiement sans interruption de service » de la console, appelée zero-downtime en ligne de commande. Si vous la désactivez (clever config update --disable-zero-downtime), l’ancienne instance s’arrête avant que la nouvelle démarre, et le scaling provoque alors une coupure. Les cas où ce réglage se justifie sont rares, sauf pour une application qui ne supporte vraiment pas de tourner en deux exemplaires, même brièvement.
Pour une hausse de CPU, comptez donc quelques minutes entre le début du pic et la mise en service de la nouvelle capacité. Tout cela relève du premier étage, que la plateforme assure seule. Le second, l’application, ne dépend que de vous.
Ce qui empêche une application de scaler
Car ajouter dix instances ne sert à rien si l’application garde son état en local : au mieux, les nouvelles instances restent sous-employées ; au pire, elles renvoient des résultats incohérents. Avant d’activer l’auto-scaling, quatre points méritent donc une vérification.
Les sessions stockées en mémoire locale
Un utilisateur se connecte sur l’instance A, sa requête suivante arrive sur l’instance B qui ne le connaît pas, et le voilà déconnecté. La solution consiste donc à stocker les sessions dans un service partagé, typiquement une base clé-valeur. Votre application garde ses sessions en mémoire et vous ne pouvez pas la modifier tout de suite ? Activez les sticky sessions avec clever config update --enable-sticky-sessions : le load balancer renverra toujours un même utilisateur vers la même instance. Ce contournement fait tourner en plusieurs exemplaires une application qui n’a pas été conçue pour, au prix d’une répartition moins fine des requêtes. Si votre application n’en a pas besoin, laissez-les désactivées.
Les fichiers écrits sur le disque local
Les fichiers posent le même problème que les sessions. Un fichier téléversé sur une instance n’existe pas sur les autres, et disparaît quand l’instance est remplacée. Les fichiers persistants ont donc leur place dans un stockage objet ou un système de fichiers partagé.
Les connexions à la base de données
Les instances partagent en revanche la base de données, et chacune y ajoute son pool de connexions : c’est le calcul des deux cents connexions vu plus haut. Dimensionnez la base en conséquence, ou placez devant elle un gestionnaire de connexions comme Pgpool-II pour PostgreSQL ou ProxySQL pour MySQL.
La base de données elle-même
Reste la base elle-même. Les bases relationnelles comme PostgreSQL ou MySQL ne se prêtent pas à l’auto-scaling d’une application : remplacer une base à chaud impose de synchroniser finement l’état des données avec sa remplaçante, et certains moteurs gardent la mémoire allouée même quand ils ne s’en servent plus, ce qui fausse la lecture de leur charge. Sur Clever Cloud, l’auto-scaling concerne donc les applications, pas les bases managées. Les stores distribués suivent une autre logique : Materia KV, construit sur FoundationDB et répliqué sur trois datacenters, repose sur un cluster dimensionné à l’échelle d’une région et conçu pour scaler horizontalement.
Ces quatre points relèvent d’un même principe, que la méthodologie Twelve-Factor formalise : des processus sans état, qui ne partagent rien entre eux, et une montée en capacité par ajout de processus. Une application qui la respecte se prête au scaling horizontal. Elle ne peut pas pour autant tout attendre de l’auto-scaling, qui réagit à la charge sans l’anticiper.
Ce que l’auto-scaling absorbe, et ce qu’il n’absorbe pas
L’auto-scaling absorbe les variations qui font partie du cycle de vie de votre application : la hausse du matin sur un outil métier, le pic de midi sur un service de livraison de repas, la clôture mensuelle sur une application comptable. Ces variations se répètent et s’observent, et vous pouvez ajuster les bornes au fil des essais.
En revanche, il n’absorbe pas les chocs. Une application qui passe de quelques centaines à des centaines de milliers de requêtes en quelques secondes, parce qu’un journal télévisé vient de la citer, sature avant la fin de la fenêtre de détection. Ces événements s’anticipent : si vous connaissez la date, relevez le nombre minimal d’instances avant l’événement plutôt que d’attendre la réaction de l’autoscaler, et placez un cache devant l’application (Varnish pour le HTTP, Redis côté applicatif) pour soulager l’application et sa base. Clément Nivolle, co-fondateur de Clever Cloud, raconte ainsi comment nous avons préparé le site de BioDemain à un passage sur M6 en 24 heures, avec Redis pour les sessions, ProxySQL pour les connexions MySQL et Varnish en option.
À l’inverse, une borne maximale trop haute peut masquer un problème. Une fuite mémoire déclenchera des montées en charge successives jusqu’à la borne maximale, et la facture suivra. Sur Clever Cloud, la console affiche l’évolution des instances, et chaque application dispose d’un dashboard Grafana qui collecte CPU, RAM et requêtes par seconde sans configuration, avec des alertes sur seuil. Un autoscaler qui bute régulièrement sur sa borne maximale signale soit une borne trop basse, soit une application qui consomme plus qu’elle ne devrait.
Dans les deux cas, le plus sûr est de connaître les limites de votre application avant qu’un pic ne les révèle.
Tester sa montée en charge avant d’en avoir besoin
C’est le rôle du test de montée en charge (load testing) : il envoie vers l’application une charge contrôlée et croissante, puis observe ses réactions, temps de réponse, taux d’erreur, déclenchement du scaling. Vous savez ainsi à partir de quelle charge l’application se dégrade, si l’autoscaler réagit au bon moment et quel composant cède en premier. Ce dernier désigne votre prochain chantier, et ce n’est pas toujours l’application, comme pour l’API bloquée à 600 requêtes par seconde.
Lancez le test de charge sur un environnement qui reproduit la production, bornes de scaling comprises, et jouez deux scénarios. Une montée progressive vérifie le comportement de l’autoscaler. Une montée brutale mesure ce que l’application encaisse avant l’arrivée de la nouvelle capacité.
Ces tests valent quel que soit l’outil qui scale votre application, plateforme managée ou Kubernetes. La différence entre les deux tient ailleurs.
Auto-scaling sur une plateforme managée ou sur Kubernetes
Kubernetes fournit son propre outillage. L’Horizontal Pod Autoscaler ajuste le nombre de réplicas d’un déploiement. Le Vertical Pod Autoscaler ajuste les ressources demandées par les pods. Le Cluster Autoscaler ajoute des nœuds quand les pods ne trouvent plus de place, et en retire quand une partie du cluster reste inoccupée. Vous choisissez les métriques, écrivez les politiques, réglez les fenêtres de stabilisation, et veillez à ce que les trois mécanismes restent cohérents entre eux : la documentation du Vertical Pod Autoscaler déconseille par exemple de le combiner avec l’Horizontal Pod Autoscaler sur une même métrique de CPU ou de mémoire.
Sur une plateforme managée, à l’inverse, la plateforme porte ces choix : vous fixez des bornes, elle décide quand agir et gère la capacité des machines sous-jacentes. Le scaling s’inscrit alors dans la même chaîne de déploiement automatisée que vos mises en production.
La différence tient donc au modèle opérationnel : la plateforme managée prend en charge l’exploitation du scaling, Kubernetes vous en donne le contrôle. Les deux font tourner des charges de production exigeantes, et le choix dépend de ce que votre équipe veut opérer elle-même. Si vous hésitez, les critères de choix d’un Kubernetes managé aident à trancher.
Votre application est-elle scalable ?
Revenons aux deux remèdes du départ : une machine plus grosse ou davantage de machines ne servent qu’à une application capable d’en profiter. Une application est scalable quand trois conditions tiennent ensemble : elle tourne en plusieurs exemplaires sans état local, ses dépendances (la base de données en tête) suivent la hausse de charge, et un test de charge l’a vérifié. L’auto-scaling automatise ensuite une capacité qui existe déjà ; il ne la crée pas. Si vous ignorez laquelle de ces trois conditions cède en premier chez vous, commencez par là, avec une question simple : quelle charge fait tomber votre application aujourd’hui ?
FAQ – Scalabilité
Quel est le synonyme de scalabilité ?
Les termes les plus proches sont extensibilité, évolutivité et passage à l’échelle. Pour l’action elle-même, on parle de montée en charge ou de mise à l’échelle, et les équipes techniques emploient les termes anglais scale up et scale out.
Que veut dire « scalable » en français ?
Est scalable un système capable de changer d’échelle : servir dix fois plus d’utilisateurs en recevant plus de ressources, sans réécriture et sans effondrement de ses performances.
Quelle différence entre scale up et scale out ?
Le scale up, ou scalabilité verticale, agrandit une instance existante. Le scale out, ou scalabilité horizontale, ajoute des instances en parallèle. Le premier ne demande rien au code mais bute sur la taille maximale d’une machine. Le second repousse ce plafond, à condition que l’application ne garde pas d’état en local.
Qu’est-ce qui déclenche l’auto-scaling ?
Un autoscaler réagit à des métriques observées. Sur Clever Cloud, il surveille le CPU et la mémoire : une activité CPU élevée de façon soutenue, sur une fenêtre de l’ordre d’une à deux minutes, déclenche une montée en charge, et une mémoire libre qui passe sous un seuil déclenche une réaction immédiate. La descente attend une charge CPU basse sur une fenêtre plus longue. Vous ne réglez pas ces seuils : vous fixez les bornes, en nombre et en taille de Scalers, entre lesquelles la plateforme agit. D’autres autoscalers, comme l’Horizontal Pod Autoscaler de Kubernetes, peuvent aussi réagir à des métriques applicatives, par exemple le nombre de requêtes.
L’auto-scaling réduit-il les coûts ?
Il évite de payer en permanence pour le pic : les ressources suivent la charge, à la hausse comme à la baisse. L’économie dépend de l’écart entre votre charge moyenne et votre charge de pointe. Une application à charge constante n’y gagne rien, une application aux variations marquées y gagne davantage. La borne maximale plafonne la dépense.
Les bases de données scalent-elles automatiquement ?
Pas les bases relationnelles classiques comme PostgreSQL ou MySQL. Remplacer une base en service suppose de transmettre son état à l’identique à sa remplaçante, et certains moteurs gardent la mémoire allouée même quand ils ne s’en servent plus, ce qui fausse la lecture de leur charge. Elles se dimensionnent à la main et se placent derrière un gestionnaire de connexions. Les stores distribués, conçus en cluster, scalent horizontalement par construction.
Qu’est-ce qu’un produit ou un modèle économique scalable ?
Dans le vocabulaire de l’entreprise, un modèle scalable augmente ses revenus plus vite que ses coûts, comme un logiciel en abonnement dont chaque nouveau client coûte peu à servir. La scalabilité technique en est une condition : sans infrastructure capable de suivre, la croissance commerciale bute sur la technique.