PostgreSQL Scaling en 2026 : Répliquer, Partitionner ou Sharder ?
La plupart des bases Postgres n'ont jamais besoin de sharding. Mais au mauvais moment, choisir la mauvaise voie peut gâcher plusieurs mois de travail et six chiffres en budget. Ce guide vous accompagne à chaque étape, d'un serveur à 100 $/mois jusqu'à un cluster distribué, avec des seuils de coût réels, des délais concrets et des règles de décision claires pour agir avant que votre base de données ne devienne une crise.
Le serveur unique comme base : ce que vous obtenez vraiment
Une instance Postgres correctement réglée supporte bien plus que ce que la plupart des équipes anticipent. Sur RDS db.r6g.2xlarge ou un niveau Supabase Pro comparable, vous disposez de 5 000 à 10 000 connexions simultanées (gérées via PgBouncer), de 1 à 2 To de stockage utilisable, et d'une facture mensuelle de 100 à 300 $. Cela suffit à la grande majorité des produits SaaS jusqu'en Series A.
Le mot clé est « correctement réglée ». La configuration Postgres par défaut est conservatrice. Ajuster work_mem, effective_cache_size, max_parallel_workers_per_gather et les paramètres d'autovacuum en fonction de votre profil de charge génère souvent une amélioration du débit de 50-100 % sans toucher au matériel. Ajoutez des index partiels sur les colonnes filtrées à haute cardinalité et des index couvrants sur les chemins de lecture les plus sollicités, et vous pouvez aller 2 à 3 fois plus loin sur la même machine.
Ne sautez pas cette étape. Les équipes qui passent directement à la réplication ou au sharding parce qu'elles ont une requête lente règlent généralement le mauvais problème. Profilez d'abord avec pg_stat_statements. Identifiez les 10 requêtes les plus coûteuses en temps total. Corrigez-les. La plupart des problèmes de « scaling » sous 1 000 RPS sont des problèmes d'index.
Règle de décision : si vous êtes sous 100 Go de données et sous 1 000 RPS, restez sur un serveur unique. Un point, c'est tout.
Scaling vertical et PgBouncer : le multiplicateur 2-3x peu coûteux
Avant d'ajouter des serveurs, épuisez le scaling vertical. Passer d'une instance RDS 4 cœurs à 16 cœurs coûte de l'argent, mais bien moins en temps d'ingénierie que de mettre en place la réplication. Le scaling vertical de Postgres est linéaire jusqu'à environ 32 cœurs pour les charges liées au CPU, et les IOPS de stockage évoluent avec la classe d'instance sur la plupart des plateformes managées.
PgBouncer est incontournable à toute échelle significative. Postgres crée un processus par connexion. Avec 500 connexions applicatives réelles sans pooling, vous gaspillez 5-10 Go de RAM en overhead de processus et consommez un CPU significatif en changements de contexte. PgBouncer en mode transaction multiplex des centaines de threads applicatifs sur 20-50 connexions Postgres réelles. Cela seul réduit souvent la pression mémoire de 40 % et améliore la latence de queue.
L'optimisation des requêtes, combinée au scaling vertical et à un pooling correct, délivre typiquement l'amélioration complète de 2-3x par rapport à une configuration par défaut. Prévoyez deux semaines pour un sprint d'optimisation ciblé : une semaine pour le profilage et le travail sur les index, une semaine pour la configuration du pool de connexions et l'élimination des requêtes lentes. Ces deux semaines de travail d'ingénierie, à 150-200 $/h pour un DBA senior, coûtent 12 000 à 16 000 $ et permettent souvent de repousser le besoin de réplication de 12-18 mois.
Règle de décision : avant d'ajouter toute complexité topologique, lancez le sprint d'optimisation. Si vous ne pouvez toujours pas atteindre vos objectifs de latence, répliquez.
Réplicas en lecture : l'outil adapté à 80 % des problèmes de passage à l'échelle
Les applications web lisent bien plus qu'elles n'écrivent, typiquement dans un rapport de 10:1 ou plus. La réplication en streaming de Postgres vous permet de router toutes les lectures (tableaux de bord, vues de liste, recherche, rapports) vers des réplicas, tandis que le primaire ne gère que les écritures. C'est le levier de scaling le plus rentable disponible.
Une configuration de production standard avec 1 primaire et 2 réplicas triple approximativement votre débit en lecture et assure la haute disponibilité. À 300-1 000 $/mois pour ce niveau sur RDS ou Supabase, vous couvrez la plupart des applications jusqu'à 5 000 RPS, si la séparation lecture/écriture est propre. Ajouter un troisième ou quatrième réplica pour les charges analytiques qui effectuent des scans complets de table empêche ces requêtes coûteuses d'affamer votre primaire.
La mise en place de la réplication prend environ une semaine pour une équipe expérimentée : configurer la réplication en streaming, mettre à jour les chaînes de connexion applicatives pour diriger les lectures vers un pool de réplicas (PgBouncer gère cela nativement avec server_round_robin), tester le basculement, terminé. Le principal coût récurrent est la surveillance du décalage de réplication. La réplication synchrone élimine le décalage mais augmente la latence des écritures (généralement 5-15 ms pour des réplicas dans la même région). La réplication asynchrone préserve la vitesse d'écriture mais les réplicas peuvent accuser un retard de quelques secondes en cas de pression en écriture.
La réplication ne résout pas le problème de taille du jeu de données. Tous les réplicas portent une copie complète. Si le problème est qu'une table est trop volumineuse pour être interrogée efficacement, la réplication accélère la lecture d'une grande table sur plusieurs serveurs, mais la table reste grande. C'est un problème de partitionnement ou de sharding.
Règle de décision : si les lectures dépassent largement les écritures et que vous êtes sous 1 To, répliquez avant tout le reste.
Cache Redis : réduire 60-80 % de la charge avant qu'elle n'atteigne Postgres
Ajouter une couche Redis entre votre application et Postgres est presque toujours le changement d'infrastructure avec le meilleur retour sur investissement après l'optimisation des index. Redis à 50-200 $/mois sur ElastiCache ou Upstash gère des lectures sous la milliseconde pour les données chaudes. Le résultat typique est une réduction de 60-80 % du volume de requêtes Postgres pour les applications ayant des modèles de lecture répétée significatifs.
Les cas qui en bénéficient le plus sont les données de session, les lectures de profil utilisateur, les vérifications de permissions, et tout comptage agrégé ou résumé qui change rarement mais est lu à chaque chargement de page. Mettez ces éléments en cache avec un TTL de 60 secondes et votre pool de réplicas Postgres dispose soudain de la capacité pour traiter 5 fois plus de trafic qu'il ne gérait avec peine.
L'invalidation du cache est le coût d'implémentation. Le cache en écriture directe (mettre à jour Redis et Postgres ensemble à chaque écriture) est le modèle le plus sûr mais exige de la rigueur sur chaque chemin d'écriture. Le cache-aside (lire depuis Redis, se rabattre sur Postgres en cas de miss, alimenter le cache) est plus simple à ajouter progressivement. Prévoyez une semaine pour une implémentation de couche de cache couvrant vos chemins de lecture les plus sollicités.
Ne mettez pas en cache des données qui doivent être fortement cohérentes : soldes financiers, stocks, tout ce qui est soumis à des exigences légales d'auditabilité. Mettez en cache la couche de reporting, pas la couche transactionnelle.
Le coût total d'un serveur unique bien réglé avec réplicas et Redis est de 350 à 1 200 $/mois selon le niveau. Cette combinaison couvre les besoins en infrastructure de la plupart des produits SaaS financés par des VC jusqu'à leurs premiers millions d'utilisateurs.
Partitionnement de tables : performances sans complexité de distribution
Le partitionnement divise une table logique en plusieurs tables physiques enfants au sein de la même base de données. Le partitionnement natif de PostgreSQL (disponible depuis la v10, mature depuis la v12) prend en charge le partitionnement par plage (découpage par date ou plage d'ID), par liste (découpage par catégorie ou tenant) et par hachage (découpage par hachage de clé). La base gère le routage de façon transparente : vos requêtes ciblent la table parente et le planificateur de requêtes élimine les partitions non pertinentes.
Le gain de performance est réel. Une table d'événements de 500 Go partitionnée par mois signifie qu'une requête sur le mois dernier scanne 40 Go au lieu de 500 Go. La taille des index diminue proportionnellement. Le vacuum s'exécute plus vite. La suppression d'anciennes partitions est instantanée (DROP TABLE sur l'enfant), contre le cauchemar de supprimer des millions de lignes d'une table monolithique.
Le partitionnement est la bonne décision quand votre problème est la performance des requêtes sur de grandes tables, pas le débit brut. Il ne distribue pas la charge entre serveurs. Toutes les partitions résident sur la même instance Postgres. Vous obtenez des requêtes plus rapides et une gestion du cycle de vie des données simplifiée, pas un scaling horizontal.
Pour un SaaS multi-tenant, le partitionnement par liste selon l'ID du tenant mérite d'être envisagé à partir de 100 000 tenants. Cela maintient les données des tenants physiquement séparées, simplifie la suppression des données pour les demandes RGPD et accélère les requêtes limitées à un tenant.
Partitionner une table existante nécessite une migration avec une fenêtre de maintenance (ou une migration en ligne soigneuse utilisant la réplication logique). Prévoyez quatre à huit semaines pour une migration de production prudente sur une table de plus de 100 Go.
Règle de décision : si le problème est la lenteur des requêtes sur de grandes tables, partitionnez avant de sharder.
Sharding : quand en avez-vous vraiment besoin et quel en est le coût
Le sharding distribue les données entre plusieurs serveurs Postgres indépendants en utilisant une clé de shard. Chaque serveur détient un sous-ensemble des données. Une recherche d'utilisateur va vers le shard qui possède cet ID utilisateur. Une requête couvrant plusieurs utilisateurs doit être ventilée vers plusieurs shards et les résultats fusionnés. C'est l'architecture qui offre un scaling horizontal théoriquement illimité.
Mais le coût opérationnel et de développement est sévère. Les transactions entre shards nécessitent une coordination au niveau applicatif ou un coordinateur de transactions distribuées (les deux ajoutent de la latence et de la complexité). Les clés étrangères entre shards n'existent pas. Les jointures entre shards sont côté application. Les migrations de schéma doivent être appliquées sur chaque shard en séquence. Les requêtes analytiques nécessitant toutes les données doivent agréger sur tous les shards. Votre ORM ne fera pas la plupart de cela pour vous.
PlanetScale (basé sur MySQL, mais le modèle est instructif), Citus (vrai sharding Postgres) et le sharding au niveau applicatif avec une couche de routage sont les trois voies d'implémentation. Citus s'intègre le plus proprement avec l'outillage Postgres existant. Le sharding applicatif vous donne le plus de contrôle mais nécessite le plus de code.
Références réelles : Notion a shardé son Postgres à 30 millions d'utilisateurs. OpenAI a évolué jusqu'à 800 millions d'utilisateurs via l'optimisation des requêtes et plus de 50 réplicas en lecture sans jamais sharder. La leçon est claire. Le sharding est un dernier recours, pas une stratégie de scaling.
Délai : une implémentation de sharding prend 8 à 12 semaines pour une équipe d'ingénierie concentrée, plus une charge de maintenance continue équivalente à 0,5-1 ETP. Avec des salaires d'ingénieur senior de 180 000-220 000 $ en 2026, cela représente 70 000-130 000 $ rien qu'en coût d'ingénierie initial, avant la facture d'infrastructure.
Règle de décision : ne shardez pas tant que vous n'êtes pas au-dessus de 1 To de données, au-dessus de 10 000 RPS, et que vous n'avez pas réellement épuisé les réplicas et le cache.
La progression de scaling : seuils et budget
Il existe une progression standard qui vaut pour la grande majorité des déploiements Postgres. Suivez-la dans l'ordre et n'avancez que lorsque l'étape en cours est véritablement saturée.
Étape 1, sous 100 Go et sous 1 000 RPS : serveur unique, 100-300 $/mois. Optimisez les requêtes et les index, configurez PgBouncer, dimensionnez correctement l'instance. Cela suffit pour la plupart des produits en phase pré-croissance.
Étape 2, de 100 Go à 1 To et de 1 000 à 5 000 RPS : réplicas et cache, 300-1 000 $/mois. Ajoutez 2-3 réplicas en lecture, routez les lectures via PgBouncer, ajoutez Redis pour les données chaudes. Ce niveau couvre la majorité des entreprises SaaS en Series A à Series B.
Étape 3, au-dessus de 1 To et au-dessus de 5 000 RPS : partitionnement et potentiellement sharding, à partir de 1 000 $/mois selon le nombre de shards. À ce stade, vous gérez une opération sérieuse d'ingénierie des données.
Ces étapes ne sont pas rigides, ce sont des déclencheurs de décision. Une charge intensive en écriture (traitement de paiements, télémétrie IoT) atteint les limites de l'étape 3 plus vite qu'une charge intensive en lecture. Une table de séries temporelles bien partitionnée à 2 To peut encore fonctionner efficacement sans sharding. Le contexte compte.
Le saut de coût entre étapes est d'environ 3 à 5 fois à chaque fois. Le saut de complexité d'ingénierie est de 1x à 3x à 10x. Cette asymétrie explique pourquoi « shardons simplement » est presque toujours la mauvaise réponse du point de vue commercial.
Des idées opérationnelles chaque semaine
Rejoignez les dirigeants d’entreprises de services qui reçoivent chaque semaine une idée concrète sur les opérations, l’automatisation et la croissance.
Pas de spam. Désabonnement à tout moment.
Vous êtes inscrit ! Surveillez votre boîte de réception pour le prochain numéro.
L’envoi a échoué. Réessayez ou écrivez à [email protected].
Compromis de cohérence et recommandations multi-tenant
Chaque décision de scaling modifie votre modèle de cohérence. Une seule instance Postgres vous offre une cohérence ACID complète. Dès que vous ajoutez des réplicas, vous avez un décalage de réplication : les lectures depuis un réplica peuvent voir des données en retard de quelques millisecondes à quelques secondes par rapport au primaire. Pour la plupart des chemins de lecture, c'est acceptable. Pour la cohérence lecture-après-écriture (un utilisateur soumet un formulaire et voit immédiatement le résultat), vous devez router ces lectures vers le primaire ou attendre la confirmation du réplica.
Le sharding rompt entièrement la cohérence distribuée. Un transfert de fonds d'un utilisateur sur le shard 1 vers un utilisateur sur le shard 2 est désormais une transaction distribuée. PostgreSQL ne coordonne pas ces opérations nativement. Vous avez besoin d'un commit en deux phases, d'un pattern saga, ou vous acceptez la cohérence éventuelle pour les opérations inter-shards. La plupart des systèmes shardés choisissent le pattern saga avec des transactions compensatoires, ce qui nécessite une logique applicative significative.
Pour un SaaS multi-tenant, le choix du modèle d'isolation compte. Le schéma partagé (tous les tenants dans une base de données, colonne tenant_id partout) est le moins coûteux à exploiter et passe à l'échelle jusqu'à des millions de petits tenants. Le schéma par tenant (un schéma Postgres par tenant dans une base de données) offre une meilleure isolation et facilite la sauvegarde/restauration par tenant, mais le comportement du pool de connexions Postgres se dégrade au-delà de quelques milliers de schémas. La base de données par tenant est l'isolation la plus forte mais est coûteuse opérationnellement et constitue essentiellement une stratégie de sharding manuel.
Pour la plupart des SaaS B2B : schéma partagé jusqu'à 100 000 tenants, puis évaluez le schéma par tenant ou le partitionnement par tenant. Base de données par tenant uniquement si une isolation contractuelle est requise (contrats enterprise SOC 2, santé, finance).
Comment Pineido cadre le travail d'architecture de base de données
Les décisions d'architecture de base de données sont généralement prises trop tard, en réaction à un incident plutôt que dans le cadre d'une construction initiale. Pineido cadre le travail d'infrastructure et de backend sous forme de sprints à prix fixe de 30 jours, ce qui signifie que vous connaissez le coût avant le démarrage et qu'il n'y a aucune incitation à la sur-ingénierie liée aux heures facturables.
Un sprint typique couvre le cycle complet d'optimisation (profilage, travail sur les index, configuration de PgBouncer) et met en place la topologie de réplication adaptée à votre niveau de trafic actuel, avec surveillance et runbooks. Les migrations de sharding sont cadrées séparément étant donné le délai de 8-12 semaines. Si vous évaluez ce dont votre Postgres a besoin aujourd'hui et dans 12 mois, le bon point de départ est le sprint de développement d'applications et de sites web ou l'engagement CTO fractionnel pour une revue d'architecture. Les détails et un devis fixe sont disponibles sur demande.
Questions fréquentes
Quand faut-il partitionner une table PostgreSQL ?
Partitionnez quand une seule table est assez volumineuse pour que les requêtes scannent plus de données que nécessaire et que le vacuum devient lent. Le déclencheur pratique est une table dépassant 50-100 Go avec des requêtes de plage fréquentes (par date, ID de tenant ou statut). Le partitionnement par plage par mois est le modèle le plus courant pour les tables d'événements et de logs. Le partitionnement maintient tout dans une seule base de données, donc sans problèmes de cohérence inter-shards. C'est aussi le bon choix avant d'envisager le sharding.
Quel est le coût d'une implémentation du sharding PostgreSQL ?
Comptez 8 à 12 semaines de travail d'ingénierie concentré. Aux tarifs 2026 d'un ingénieur senior (180 000-220 000 $ par an), cela représente 70 000-130 000 $ en main-d'œuvre seule. Les coûts d'infrastructure passent à 1 000 $/mois et plus selon le nombre de shards. Il faut également prévoir une charge opérationnelle récurrente équivalant à environ 0,5-1 ETP pour les migrations, le rééquilibrage et la surveillance. Ces coûts expliquent pourquoi le sharding doit être reporté aussi longtemps que possible.
Combien de réplicas en lecture PostgreSQL faut-il pour gérer un trafic élevé ?
Une configuration 1 primaire plus 2 réplicas gère la plupart des charges de production jusqu'à 5 000 RPS quand la séparation lecture/écriture est propre. L'ajout d'un cache Redis en amont réduit le volume de lectures en base de 60-80 %, donc vos réplicas couvrent bien plus de trafic que le chiffre brut de RPS ne le laisse supposer. OpenAI est passé à 800 millions d'utilisateurs avec plus de 50 réplicas et un cache agressif sans jamais sharder. Commencez avec 2 réplicas et ajoutez-en au fur et à mesure que le volume de requêtes augmente.
Faut-il utiliser Citus ou le sharding applicatif pour PostgreSQL ?
Citus est la voie la plus propre si vous êtes engagé à rester dans l'écosystème Postgres. Il s'intègre avec l'outillage Postgres standard, gère le routage des requêtes de façon transparente et supporte les jointures distribuées dans certaines limites. Le sharding applicatif vous donne un contrôle total sur la logique de routage et évite la dépendance à Citus, mais chaque jointure, transaction et migration de schéma devient du code applicatif. Pour la plupart des équipes, Citus est le meilleur point de départ. Le sharding applicatif a du sens si votre logique de sharding est très spécifique à votre domaine.
PgBouncer est-il indispensable pour les déploiements PostgreSQL en production ?
Oui, à toute échelle significative. Postgres crée un processus par connexion, ce qui consomme environ 5-10 Mo de RAM chacun. Avec 500 connexions applicatives sans pooling, vous gaspillez 2,5-5 Go en overhead de processus avant d'exécuter la moindre requête. PgBouncer en mode transaction multiplex des centaines de threads applicatifs sur 20-50 connexions Postgres. C'est un élément indispensable de toute configuration de production au-delà d'un prototype mono-utilisateur ou à faible trafic, et il se configure en moins d'une journée.
Prêt à livrer ?
Dites-nous où vous bloquez. Nous l’examinons et vous envoyons une recommandation ciblée sous un jour ouvré.