La question "comment on isole les données entre clients" arrive tôt dans tout SaaS B2B, et la réponse qu'on donne au premier client conditionne l'architecture pour les deux prochaines années. Changer de stratégie de multi-tenancy après coup, une fois cent clients en production, est un projet de migration en soi, pas un refactoring. Mieux vaut comparer les options sérieusement dès le départ plutôt que de partir sur la première qui compile.

Le problème concret

Un SaaS de gestion pour cabinets comptables ou agences immobilières doit garantir qu'un cabinet A ne peut jamais, même par un bug applicatif, voir une ligne de données du cabinet B. Trois architectures répondent à ce besoin en Laravel, avec des garanties et des coûts opérationnels très différents : une base de données par tenant, un schéma PostgreSQL par tenant, ou une colonne tenant_id partagée dans des tables communes.

Les trois stratégies et leur mécanisme

Base de données par tenant

Chaque tenant a sa propre base. Laravel résout la connexion dynamiquement selon le tenant courant, généralement identifié par sous-domaine ou en-tête.

// Résolution de la connexion selon le tenant courant
class TenantDatabaseMiddleware
{
    public function handle(Request $request, Closure $next)
    {
        $tenant = Tenant::where('domain', $request->getHost())->firstOrFail();

        config([
            'database.connections.tenant.database' => $tenant->database_name,
        ]);
        DB::purge('tenant');
        DB::setDefaultConnection('tenant');

        return $next($request);
    }
}

L'isolation est garantie au niveau du moteur de base de données lui-même : une requête mal écrite qui oublie un WHERE tenant_id = ? ne peut physiquement pas remonter les données d'un autre tenant, puisqu'elles ne sont pas dans la même base. C'est la garantie la plus forte des trois options.

Le coût : les migrations doivent s'exécuter sur N bases, les connexions aux pools de bases doivent être gérées dynamiquement (risque de fuite de connexions si DB::purge() est oublié), et les requêtes cross-tenant (reporting global, facturation centralisée) deviennent nettement plus complexes, puisqu'il faut agréger depuis plusieurs bases séparées.

Schéma PostgreSQL par tenant

Même principe d'isolation logique, mais à l'intérieur d'une seule instance PostgreSQL, via le search_path.

class TenantSchemaMiddleware
{
    public function handle(Request $request, Closure $next)
    {
        $tenant = Tenant::where('domain', $request->getHost())->firstOrFail();

        DB::statement("SET search_path TO \"{$tenant->schema_name}\", public");

        return $next($request);
    }
}
-- Création d'un nouveau tenant : un schéma + migration dans ce schéma
CREATE SCHEMA tenant_acme;
# Migration exécutée dans le contexte du schéma du tenant
php artisan tenants:migrate --schema=tenant_acme

Cette approche garde une seule instance de base à administrer (sauvegardes, monitoring, mises à jour PostgreSQL) tout en conservant une isolation logique forte. C'est un bon compromis entre robustesse et coût opérationnel, mais elle est spécifique à PostgreSQL (MySQL n'a pas d'équivalent exact au search_path) et impose une attention particulière : un search_path mal réinitialisé entre deux requêtes dans un pool de connexions réutilisées peut faire fuiter des données d'un tenant vers un autre. Il faut absolument réinitialiser le search_path à chaque requête entrante, jamais seulement à la connexion.

Colonne tenant_id partagée

Toutes les données vivent dans les mêmes tables, avec une colonne tenant_id et un filtre appliqué systématiquement.

// Global scope appliqué automatiquement à chaque requête Eloquent
class TenantScope implements Scope
{
    public function apply(Builder $builder, Model $model): void
    {
        if ($tenantId = app('currentTenant')?->id) {
            $builder->where($model->getTable() . '.tenant_id', $tenantId);
        }
    }
}

class Invoice extends Model
{
    protected static function booted(): void
    {
        static::addGlobalScope(new TenantScope);

        static::creating(function (Invoice $invoice) {
            $invoice->tenant_id = app('currentTenant')->id;
        });
    }
}

C'est l'option la moins chère à opérer (une seule base, un seul schéma de migration, un seul pool de connexions) et la plus simple pour du reporting cross-tenant. Le revers : l'isolation dépend entièrement de la discipline applicative. Un Model::query() qui bypass le global scope, une requête SQL brute (DB::table()) sans filtre explicite, ou un job en file d'attente exécuté hors du contexte HTTP (donc sans tenant résolu par le middleware) peuvent exposer des données d'un tenant à un autre. C'est historiquement la source de la majorité des incidents de sécurité multi-tenant documentés publiquement (CVE et rapports de bug bounty sur des SaaS).

Diagnostiquer les fuites dans une implémentation par colonne

Si cette troisième stratégie est déjà en place, l'audit prioritaire consiste à lister tout accès aux tables tenant-scopées qui ne passe pas par le global scope :

# Repérer les requêtes brutes qui contournent potentiellement le scope
grep -rn "DB::table(" app/ --include="*.php" | grep -v "tenant_id"

# Repérer les jobs qui accèdent à des modèles tenant-scopés
grep -rln "implements ShouldQueue" app/Jobs/

Chaque job trouvé par la deuxième commande doit être vérifié manuellement : s'il manipule un modèle avec TenantScope, le tenant doit être sérialisé explicitement dans le job et réappliqué au moment de l'exécution, pas supposé disponible via un contexte de requête HTTP qui n'existe plus en file d'attente.

class GenerateInvoicePdf implements ShouldQueue
{
    public function __construct(private int $tenantId, private int $invoiceId) {}

    public function handle(): void
    {
        app()->instance('currentTenant', Tenant::find($this->tenantId));
        // Le global scope s'applique maintenant correctement
        $invoice = Invoice::findOrFail($this->invoiceId);
        // ...
    }
}

Les compromis, posés explicitement

| Critère | Base par tenant | Schéma par tenant | Colonne tenant_id | |---|---|---|---| | Force de l'isolation | Maximale (moteur DB) | Forte (moteur DB, PostgreSQL) | Dépend du code applicatif | | Coût opérationnel | Élevé (N bases à sauvegarder/monitorer) | Modéré | Faible | | Reporting cross-tenant | Complexe (agrégation multi-bases) | Modéré | Simple | | Portabilité SGBD | Oui | Non (spécifique PostgreSQL) | Oui | | Scalabilité au nombre de tenants | Limitée (pools de connexions) | Bonne jusqu'à plusieurs centaines | Excellente |

Il n'y a pas de "meilleure" option dans l'absolu : un SaaS vendu à des grands comptes avec des exigences de conformité fortes (santé, finance réglementée) justifie souvent le coût opérationnel d'une base par tenant pour la garantie d'isolation qu'elle apporte au contrat. Un SaaS B2B à forte volumétrie de petits comptes (des milliers de tenants) tolère rarement une base par tenant et se tourne naturellement vers la colonne partagée, avec une discipline de code stricte pour compenser.

Quand la colonne partagée devient risquée

Si le produit traite des données réglementées (santé, données bancaires) ou si un client impose contractuellement une isolation physique démontrable en audit, la colonne tenant_id seule ne suffit généralement pas, quelle que soit la qualité du code : un auditeur de sécurité externe demandera une preuve d'isolation au niveau infrastructure, pas une garantie applicative. Dans ce cas, le schéma par tenant (ou la base par tenant pour les exigences les plus strictes) n'est pas une option parmi d'autres, c'est une contrainte imposée par le contexte réglementaire.

Une approche hybride à considérer : colonne partagée avec réplique dédiée au reporting

Un point qui revient trop rarement dans cette discussion : la colonne tenant_id partagée n'impose pas forcément une base unique et indifférenciée pour toute charge. Pour les requêtes de reporting et d'analytique qui scannent l'ensemble des tenants (tableaux de bord d'usage, agrégation de facturation), router ces lectures vers une réplique dédiée évite que ces scans lourds n'entrent en concurrence avec les requêtes sensibles à la latence qui servent le trafic tenant en direct.

// config/database.php
'connections' => [
    'mysql' => [
        // connexion principale, pour toutes les écritures/lectures tenant-scopées
    ],
    'mysql_reporting' => [
        // réplique en lecture, dédiée à l'agrégation cross-tenant
        'read' => [
            'host' => [env('DB_REPORTING_HOST')],
        ],
        'sticky' => false,
    ],
],
class TenantUsageReport
{
    public function generate(): Collection
    {
        return DB::connection('mysql_reporting')
            ->table('invoices')
            ->selectRaw('tenant_id, SUM(amount) as total')
            ->groupBy('tenant_id')
            ->get();
    }
}

Ça ne change pas le modèle d'isolation (le global scope continue de gouverner le trafic applicatif tenant-scopé) ; c'est un raffinement opérationnel qui évite qu'un job de reporting ne dégrade le temps de réponse de tous les tenants à la fois, un mode de défaillance facile à négliger jusqu'à ce qu'une requête de dashboard verrouille une ligne dont une requête côté client a aussi besoin.

Tester l'isolation, pas seulement lui faire confiance

Quelle que soit la stratégie retenue, la garantie d'isolation doit être adossée à un test automatisé qui essaie activement de la casser, pas seulement à la vigilance en revue de code.

public function test_user_cannot_access_another_tenants_invoice(): void
{
    $tenantA = Tenant::factory()->create();
    $tenantB = Tenant::factory()->create();

    $invoice = Invoice::factory()->for($tenantB)->create();

    $this->actingAsTenant($tenantA)
        ->get("/invoices/{$invoice->id}")
        ->assertNotFound(); // jamais assertForbidden : l'existence elle-même ne doit pas fuiter
}

Attendre un 404 plutôt qu'un 403 compte ici : un 403 confirme que la ressource existe sous un autre tenant, ce qui constitue déjà une petite fuite d'information dans un contexte multi-tenant strict. Ce seul test, exécuté à chaque pipeline, détecte la régression la plus fréquente d'une implémentation par colonne partagée : un nouvel endpoint ou un job ajouté sans le filtre tenant appliqué.

À retenir

Le choix entre base, schéma et colonne partagée n'est pas une question de préférence technique mais de ce que le contrat avec les clients et la réglementation exigent en matière de preuve d'isolation. La colonne partagée avec global scope est le choix par défaut le plus économique, à condition d'auditer systématiquement les accès bruts et les jobs en file d'attente qui peuvent la contourner.