{"canonical_url":"https://engineer.company/fr/glossary/scalability/","content_markdown":"# Scalabilité\n\n## Ce que c'est\n\nLa scalabilité décrit la façon dont la capacité d’un système augmente lorsqu’on lui ajoute des ressources. Un système passe bien à l’échelle lorsque deux fois plus de machines supportent environ deux fois plus de charge avec les mêmes temps de réponse. Il passe mal à l’échelle lorsque le matériel supplémentaire attend surtout quelque chose qu’il ne peut pas aider à accomplir. Le mot décrit une relation entre charge et coût, pas une caractéristique qu’un système possède ou non.\n\nIl existe deux directions de croissance. La mise à l’échelle verticale consiste à utiliser une machine plus puissante : davantage de cœurs et de mémoire, des disques plus rapides. Elle ne demande aucune modification du logiciel et s’arrête à la plus grosse machine qu’il reste rentable d’acheter. La mise à l’échelle horizontale consiste à répartir le travail entre davantage de machines. Elle n’a pas ce plafond, mais ne profite qu’aux tâches divisibles.\n\nHTTP a été conçu en tenant compte de cette croissance horizontale. La RFC 9110 note que de nombreuses implémentations s’appuient sur l’absence d’état de HTTP pour réutiliser des connexions passant par des proxys ou répartir dynamiquement les requêtes entre plusieurs serveurs. Une couche web qui ne conserve rien entre les requêtes peut croître par ajout de copies derrière un répartiteur de charge. Chacune peut répondre à n’importe quelle requête.\n\nLa charge a plusieurs dimensions. Un système peut progresser sur l’une et bloquer sur une autre : requêtes par seconde, volume de données stockées, nombre d’organisations clientes et nombre de clients qui tentent d’écrire simultanément dans le même enregistrement. Cette dernière dimension est la plus difficile : une seule transaction peut modifier une ligne à la fois, quel que soit le nombre de serveurs autour.\n\nLa loi d’Amdahl en donne l’arithmétique. Lorsqu’une partie du travail doit s’exécuter en séquence, le matériel parallèle n’accélère que le reste. La partie séquentielle fixe donc la limite : avec 5 % du travail en série, la tâche complète ne peut jamais être accélérée de plus de 20 fois, même sur mille machines. Dans une base de données, cette partie est souvent un verrou. Dans une application, c’est souvent un élément partagé : un compteur, une file d’attente ou un stockage de sessions.\n\n## Pourquoi c'est important\n\nLa scalabilité détermine le coût de la croissance. Lorsqu’un système passe bien à l’échelle, doubler le trafic représente une ligne sur une facture. Lorsqu’il le fait mal, la facture augmente plus vite que la charge, ou ajouter du matériel n’aide plus du tout. La correction devient alors une refonte menée pendant que le trafic continue d’arriver.\n\nLe matériel peut soulager les goulets d’étranglement des processeurs, de la mémoire ou des disques, mais le travail inefficace et les contraintes d’exécution séquentielle peuvent persister. Une requête qui parcourt inutilement une table entière peut encore effectuer du travail superflu sur un serveur plus puissant. Une machine plus puissante ne supprime pas l’exécution séquentielle des mises à jour d’une même ligne partagée, et des serveurs applicatifs supplémentaires peuvent ajouter à la file d’attente des clients qui effectuent des écritures. La plupart des systèmes semblant nécessiter davantage de machines ont d’abord besoin qu’on les examine.\n\nDans PostgreSQL, l’examen commence par `pg_stat_statements`, une extension qui enregistre chaque instruction normalisée avec son nombre d’appels et son temps d’exécution. Un tri par temps total plutôt que moyen montre où le serveur dépense réellement ses ressources : une requête de 2 ms exécutée un million de fois par heure coûte 2 000 secondes de cette heure, contre quatre pour un rapport de deux secondes lancé deux fois.\n\n```sql\nSELECT calls, round(total_exec_time) AS total_ms,\n       left(query, 60) AS query\n  FROM pg_stat_statements\n ORDER BY total_exec_time DESC\n LIMIT 10;\n```\n\nChaque étape vers davantage de machines entraîne ses propres coûts d’exploitation, d’où l’importance de l’ordre. Une instruction plus efficace ou un meilleur index peut améliorer les performances sans ajouter de serveur. Un réplicat de lecture relève de la configuration. Le partitionnement modifie une table. Le sharding, qui répartit les données entre serveurs de bases de données distincts, modifie aussi l’exploitation : les migrations, sauvegardes, restaurations et rapports doivent tenir compte des shards distincts ; une jointure entre shards peut être déplacée dans le code applicatif ; une requête ignorant sa clé de sharding peut devoir les interroger tous.\n\n## À quoi cela ressemble en pratique\n\nUne base PostgreSQL derrière une application de taille moyenne contenait les comptes utilisateurs, les organisations clientes, les données géographiques et la consommation électrique quotidienne. Le trafic était faible, mais la base ralentissait à mesure que les données augmentaient. L’objectif était de la rendre [dix fois plus rapide sans refondre l’architecture](/fr/portfolio/accelerated-postgresql-performance-by-10x/), en prévoyant la croissance future des données. Le travail a porté sur des index GiST pour les données spatiales, des index composites sur l’organisation cliente et la plage de dates, le partitionnement temporel de la table de consommation électrique, le partitionnement par hachage des données géographiques, la réécriture des requêtes vérifiées avec `EXPLAIN ANALYZE` et un pool de connexions. Les temps de réponse ont été divisés par dix, l’utilisation des ressources de la base a baissé de 40 % et le système a absorbé l’augmentation des données sans ralentir, avec moins de besoins de mise à niveau du matériel.\n\nDans une entreprise de taille moyenne exploitant dix serveurs de bases PostgreSQL et SQL Server, l’infrastructure a été [dimensionnée pour absorber une hausse de 40 % du trafic utilisateur sans dégradation du service](/fr/portfolio/ran-10-postgresql-and-ms-sql-servers-on-ubuntu/). Parallèlement, les temps de réponse des requêtes ont été améliorés de 30 % grâce au réglage de la configuration et à l’optimisation des index.\n\nL’ordre du travail est présenté dans [une note sur l’optimisation avant le sharding](/fr/notes/optimise-before-you-shard/) : observer, optimiser, décharger le serveur principal des lectures, partitionner les tables autour du point chaud, puis ne répartir entre serveurs que lorsqu’une machine est saturée de travail utile. La note décrit trois cas où le sharding est raisonnable : le serveur principal est saturé par des instructions déjà efficaces, les données ont dépassé les capacités de maintenance ou l’isolation est elle-même une exigence.\n\n## Où les problèmes surviennent\n\n**Davantage de serveurs web devant une seule base.** Chaque serveur applicatif ouvre ses propres connexions. Lorsque le nombre de sessions actives dépasse de nombreuses fois le nombre de cœurs de la base, le serveur passe son temps à basculer entre elles. Un pool de connexions corrige cela avant tout ajout de matériel, et un serveur web supplémentaire aggrave le problème.\n\n**Une ligne très sollicitée.** Lorsque chaque requête écrit dans le même enregistrement, comme un compteur de stock ou un solde, le débit est limité approximativement au nombre d’écritures qu’un verrou peut traiter, divisé par sa durée de détention, quel que soit le nombre de machines. Toute opération lente sous ce verrou abaisse le plafond. Gardez les transactions courtes et les appels externes en dehors. Lorsqu’un article dépasse les capacités de sa machine, répartissez son stock en petits ensembles ayant chacun un propriétaire unique.\n\n**Un état conservé sur un seul serveur.** Des sessions dans la mémoire d’un processus, des fichiers téléversés sur son disque local ou une tâche planifiée qui suppose qu’aucune autre copie ne s’exécute empêchent une seconde instance d’être équivalente à la première. Conservez cet état dans un stockage partagé pour que chaque instance puisse répondre à n’importe quelle requête.\n\n**Des réplicats traités comme des copies du serveur principal.** Un réplicat alimenté en continu a un léger retard. Un utilisateur qui vient d’écrire puis lit sur ce réplicat peut ne pas voir son écriture : lisez les données récemment écrites sur le serveur principal. Un long rapport sur un serveur de secours peut aussi être annulé lorsqu’il retarde la réapplication des changements. PostgreSQL documente ces conflits de requêtes et les paramètres qui permettent un compromis entre eux et le retard du réplicat.\n\n**Des partitions que les requêtes ne désignent jamais.** Le partitionnement divise une table selon une clé, comme un mois ou une organisation cliente. Une requête indiquant la clé ne lit que les partitions nécessaires. Une requête qui l’omet lit toutes les partitions et ne gagne rien à cette division. Partitionnez selon les critères déjà utilisés par les requêtes et n’attendez un bénéfice que pour les grandes tables : le manuel PostgreSQL donne comme règle approximative une table dépassant la mémoire physique du serveur de base de données.\n\n## Pour aller plus loin\n\n- [RFC 9110 : sémantique HTTP, section 3.3](https://www.rfc-editor.org/rfc/rfc9110#section-3.3) — connexions, clients, serveurs et conception sans état permettant de répartir les requêtes entre plusieurs serveurs.\n- [PostgreSQL : partitionnement des tables](https://www.postgresql.org/docs/current/ddl-partitioning.html) — définition, conditions de rentabilité et élagage des partitions dont une requête ne peut pas avoir besoin.\n- [PostgreSQL : pg_stat_statements](https://www.postgresql.org/docs/current/pgstatstatements.html) — extension conservant le nombre d’appels et les durées de chaque instruction normalisée.\n- [PostgreSQL : serveur de secours en lecture](https://www.postgresql.org/docs/current/hot-standby.html) — requêtes en lecture seule et conflits pouvant les annuler.\n- [RFC 9111 : cache HTTP](https://www.rfc-editor.org/rfc/rfc9111) — stockage et réutilisation des réponses pour que les requêtes répétées n’atteignent pas nécessairement le serveur d’origine.\n\n\u003chttps://engineer.company/fr/glossary/scalability/\u003e\n","date_modified":"2026-11-09T21:50:25Z","description":"Comment la capacité évolue avec les ressources, pourquoi une étape séquentielle ou une ligne partagée la limite, et quoi mesurer avant d’ajouter un serveur.","formats":{"gemtext":"https://engineer.company/fr/glossary/scalability/index.gmi","gopher":"https://engineer.company/fr/glossary/scalability/gophermap","html":"https://engineer.company/fr/glossary/scalability/","json":"https://engineer.company/fr/glossary/scalability/index.json","markdown":"https://engineer.company/fr/glossary/scalability/index.md","pdf":"https://engineer.company/fr/glossary/scalability/index.pdf"},"kind":"page","language":"fr","title":"Qu’est-ce que la scalabilité ?","url":"https://engineer.company/fr/glossary/scalability/","version":1}