Le multi-tenancy (ou architecture multi-locataire) est un modèle dans lequel une même application sert plusieurs clients, appelés « tenants ». Chaque tenant dispose de ses utilisateurs, de ses données et parfois de sa configuration, tout en partageant le même code applicatif. Toute la question est de savoir où vivent les données de chacun, et comment garantir qu'un client ne verra jamais celles d'un autre.
Un seul axe : l'isolation
Les approches se rangent du plus mutualisé au plus cloisonné : base partagée avec colonne de discrimination, schéma par client, base par client, et enfin instance par client. Plus on isole, plus la sécurité et le RGPD sont simples ; plus on mutualise, moins l'exploitation coûte.
Une décision prise tôt
Le modèle d'isolation se choisit avant la première ligne de code métier, et se paie pendant des années. En changer une fois la plateforme en production est un chantier lourd, à mener progressivement.
Les quatre modèles en pratique
- Base partagée (pooled) : toutes les lignes portent un identifiant de tenant, et chaque requête doit filtrer dessus. C'est le moins cher et le plus scalable en nombre de clients, mais le cloisonnement repose entièrement sur le code : une requête qui oublie le filtre ne plante pas, elle fuit.
- Schéma par client : même serveur de base, mais un jeu de tables par client. Le cloisonnement devient logique, au prix de migrations à rejouer sur chaque schéma.
- Base par client (silo) : l'application est partagée, mais elle résout le client à chaque requête puis se connecte à sa base dédiée. Aucune requête ne peut traverser la frontière ; exporter un client, c'est un dump ; le supprimer, c'est un drop.
- Instance par client : application, base et ressources dédiées. Isolation totale, versions pilotables client par client, mais exploitation multipliée par le nombre de clients.
Comment je tranche
Trois critères décident : la sensibilité des données, le nombre de clients visé et la capacité d'exploitation. Pour un SaaS grand public à très grand nombre de comptes peu sensibles, la base partagée reste souvent le seul modèle viable économiquement. Pour des applications métier qui manipulent des données clients confidentielles — c'est le cas de la plupart des outils que je conçois —, je privilégie l'isolation par construction. Je préfère une sécurité garantie par l'architecture à une sécurité garantie par la discipline : un filtre bien posé est efficace tant que personne, jamais, n'écrit une requête qui le contourne ; une base par client l'est même le jour où quelqu'un se trompe.
Côté Symfony, deux mécanismes reviennent toujours. La résolution du tenant, le plus souvent par le nom de domaine, dans un listener exécuté au tout début de la requête. Puis l'aiguillage : un filtre Doctrine en base partagée, ou un middleware DBAL qui substitue les paramètres de connexion en silo — avec un garde-fou qui refuse de se connecter si aucun tenant n'est résolu.
Des exemples concrets
- Une plateforme SaaS PIM/DAM : des clients exigeants, des catalogues volumineux et parfois confidentiels, des besoins de personnalisation forts. Le choix a été l'instance par client, avec un déploiement dédié par client. Le coût d'exploitation est réel, mais il correspond à un nombre maîtrisé de clients à forte valeur.
- Une application de métrologie industrielle, en cours : base par client, résolution du tenant par le host, bascule de connexion par un middleware DBAL, et un bucket de stockage objet dédié à chaque client. Une commande provisionne la base, le bucket et la configuration d'un nouveau client ; une autre rejoue les migrations sur l'ensemble des tenants.
- Qezako : chaque marque gère ses produits, ses étiquettes et ses statistiques de scan depuis un back-office dédié, au sein d'une même application.
Les pièges à éviter
- N'isoler que la base. Les données d'un client vivent aussi dans le stockage de fichiers, le cache, le moteur de recherche, les files de messages et les journaux. Une base silo derrière un bucket partagé aux chemins devinables n'est plus un silo.
- Oublier l'asynchrone. Un worker qui consomme un message n'a plus la requête HTTP pour deviner le client : le contexte de tenant doit voyager avec le message.
- Les clés de cache sans préfixe client : deux tenants qui calculent la même clé lisent les données l'un de l'autre.
- Le SQL natif en base partagée : le filtre Doctrine ne le couvre pas. Chaque requête écrite à la main doit être revue.
- Sous-estimer les migrations en silo : sans outillage pour les propager à toutes les bases, chaque déploiement devient une opération manuelle risquée.
Le multi-tenant n'est pas un problème de framework : c'est un arbitrage entre isolation et mutualisation, décidé tôt et payé sur des années. Et un niveau d'isolation choisi ne vaut que s'il est tenu sur toutes les couches qui stockent un état.
Le choix du modèle d'isolation fait partie de mes missions d'architecture et performance applicative. Pour le détail des quatre modèles, de la grille de décision et de leur mise en œuvre avec Symfony, voir Architecture multi-tenant : quatre modèles d'isolation.