Budowa Multi-Tenant SaaS z .NET i Azure

1. Wspólna baza danych, wspólny schemat

Wszyscy tenant dzielą tabele z kolumną dyskryminatora TenantId. Najprostszy i najbardziej opłacalny model. Idealny dla platform korzystających z baz danych PostgreSQL, które oferują doskonałą wydajność dla dużej liczby tenant.

2. Wspólna baza danych, osobne schematy

Pojedyncza baza danych ze schematem-per-tenant (schematy PostgreSQL lub SQL Server). Umiarkowana izolacja.

3. Osobne bazy danych (Database-per-Tenant)

Każdy tenant dostaje dedykowaną bazę danych. Maksymalna izolacja i customizacja.

Middleware rozpoznawania Tenant

Kluczowym elementem każdej platformy multi-tenant jest poprawne rozpoznawanie tenant. W nowoczesnej platformie .NET middleware stanowi idealny punkt do implementacji tej logiki.

// Strategie identyfikacji tenant
public class TenantResolutionMiddleware
{
    public async Task InvokeAsync(HttpContext context, ITenantService tenantService)
    {
        // Strategia 1: Subdomena (tenant1.app.com)
        var host = context.Request.Host.Host;
        var tenantId = ExtractTenantFromSubdomain(host);

        // Strategia 2: Header (X-Tenant-ID)
        if (string.IsNullOrEmpty(tenantId))
            tenantId = context.Request.Headers["X-Tenant-ID"];

        // Strategia 3: JWT Claim
        if (string.IsNullOrEmpty(tenantId) && context.User.Identity?.IsAuthenticated == true)
            tenantId = context.User.FindFirst("tenant_id")?.Value;

        // KRYTYCZNE: Nigdy nie ufaj tenant ID wysłanym przez klienta dla dostępu do danych
        // Zawsze waliduj względem dozwolonych tenant uwierzytelnionego użytkownika
        var tenant = await tenantService.GetAndValidateTenantAsync(tenantId, context.User);
        context.Items["TenantId"] = tenant.Id;
    }
}

Globalne filtry zapytań (EF Core)

Automatycznie filtruj wszystkie zapytania po tenant żeby zapobiec wyciekom danych:

public class ApplicationDbContext : DbContext
{
    private readonly ITenantService _tenantService;

    public ApplicationDbContext(DbContextOptions options, ITenantService tenantService)
        : base(options)
    {
        _tenantService = tenantService;
    }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        // Zastosuj globalny filtr zapytań do wszystkich encji w zakresie tenant
        foreach (var entityType in modelBuilder.Model.GetEntityTypes())
        {
            if (typeof(ITenantEntity).IsAssignableFrom(entityType.ClrType))
            {
                var method = typeof(ApplicationDbContext)
                    .GetMethod(nameof(SetGlobalQueryFilter), BindingFlags.NonPublic | BindingFlags.Static)
                    ?.MakeGenericMethod(entityType.ClrType);

                method?.Invoke(null, new object[] { modelBuilder, _tenantService });
            }
        }
    }

    private static void SetGlobalQueryFilter<T>(ModelBuilder modelBuilder, ITenantService tenantService)
        where T : class, ITenantEntity
    {
        modelBuilder.Entity<T>().HasQueryFilter(e => e.TenantId == tenantService.GetCurrentTenantId());
    }
}

// Interfejs encji
public interface ITenantEntity
{
    string TenantId { get; set; }
}

// Przykładowa encja
public class Order : ITenantEntity
{
    public int Id { get; set; }
    public string TenantId { get; set; } // Automatycznie filtrowane
    public decimal Amount { get; set; }
}

Database-per-Tenant z rozpoznawaniem Connection String

public class TenantDbContextFactory
{
    private readonly ITenantService _tenantService;
    private readonly IConfiguration _configuration;

    public ApplicationDbContext Create()
    {
        var tenantId = _tenantService.GetCurrentTenantId();
        var connectionString = GetConnectionStringForTenant(tenantId);

        var optionsBuilder = new DbContextOptionsBuilder<ApplicationDbContext>();
        optionsBuilder.UseNpgsql(connectionString);

        return new ApplicationDbContext(optionsBuilder.Options);
    }

    private string GetConnectionStringForTenant(string tenantId)
    {
        // Opcja 1: Dedykowana baza per tenant
        return $"Host=postgres.app.com;Database=tenant_{tenantId};Username=app;Password=...";

        // Opcja 2: Azure SQL Elastic Pool z bazami
        // return $"Server=tcp:app.database.windows.net;Database=tenant_{tenantId};...";

        // Opcja 3: Wyszukiwanie z tabeli konfiguracji tenant
        // var tenant = await _tenantRepo.GetAsync(tenantId);
        // return tenant.ConnectionString;
    }
}

Azure SQL Elastic Pools

Dziel zasoby obliczeniowe między wieloma bazami danych tenant zachowując izolację.

Azure AD B2C dla Multi-Tenant Auth

Zarządzaj użytkownikami tenant z Azure AD B2C: custom policies, social login, MFA, user flows.

• • Przechowuj kontekst tenant w claimach JWT
• • Wspieraj provisioning użytkowników oparty na zaproszeniach
• • Włącz SSO dla tenant enterprise
• • Ceny: Pierwsze 50K MAU za darmo, potem $0.00325/MAU

Application Insights - Telemetria Per-Tenant

// Dodaj kontekst tenant do całej telemetrii
services.AddApplicationInsightsTelemetry();
services.AddSingleton<ITelemetryInitializer, TenantTelemetryInitializer>();

public class TenantTelemetryInitializer : ITelemetryInitializer
{
    private readonly ITenantService _tenantService;

    public void Initialize(ITelemetry telemetry)
    {
        if (telemetry is ISupportProperties propertiesTelemetry)
        {
            propertiesTelemetry.Properties["TenantId"] = _tenantService.GetCurrentTenantId();
            propertiesTelemetry.Properties["TenantName"] = _tenantService.GetCurrentTenantName();
        }
    }
}

// Zapytanie w portalu Azure:
// requests | where customDimensions.TenantId == "tenant-123" | summarize count() by bin(timestamp, 1h)

Który model multi-tenancy powinienem wybrać?

Wybierz na podstawie skali i potrzeb izolacji: wspólna baza/wspólny schemat dla 100-10,000 tenant (najniższy koszt), wspólna baza/osobne schematy dla 10-1,000 tenant (umiarkowana izolacja), osobne bazy dla tenant enterprise (maksymalna izolacja). Większość platform SaaS używa podejścia hybrydowego: wspólna baza dla SMB, dedykowana dla enterprise.

Jak obsługiwać customizacje specyficzne dla tenant?

Użyj podejścia opartego na konfiguracji: przechowuj preferencje tenant w tabelach metadanych, używaj flag funkcjonalności dla feature'ów per-tenant, implementuj architekturę plugin dla customowej logiki biznesowej. Unikaj branchy kodu specyficznych dla tenant. Zamiast tego użyj pattern strategy z dependency injection do wymiany implementacji per tenant.

Jakie są dobre praktyki bezpieczeństwa?

Kluczowe praktyki: (1) Nigdy nie ufaj tenant ID wysyłanym przez klienta, zawsze wyprowadzaj z uwierzytelnionej tożsamości, (2) Używaj globalnych filtrów zapytań EF Core żeby zapobiec wyciekom danych cross-tenant, (3) Implementuj middleware kontekstu tenant, (4) Szyfruj wrażliwe dane kluczami specyficznymi dla tenant, (5) Audituj operacje cross-tenant, (6) Testuj izolację tenant z automatycznymi testami, (7) Implementuj rate limiting per tenant.

Ile kosztuje prowadzenie na Azure?

Mały SaaS (100 tenant): $500-1,500/miesiąc. Średni SaaS (1,000 tenant): $3,000-8,000/miesiąc. Duży SaaS (10K+ tenant): $20K-50K+/miesiąc. Kluczem jest odpowiedni dobór warstwy i autoscaling. Użyj Azure Cost Management do monitoringu i reserved instances dla 40% oszczędności na przewidywalnych obciążeniach.

Czy mogę zmigrować z single-tenant do multi-tenant?

Tak, podejście fazowe: (1) Dodaj kontekst tenant do tabel, (2) Implementuj middleware rozpoznawania tenant, (3) Zaktualizuj kod żeby filtrować po tenant ID, (4) Skonsoliduj bazy z migracją danych, (5) Testuj pod kątem wycieków danych, (6) Uruchom równolegle dla walidacji. Spodziewaj się 3-6 miesięcy dla migracji produkcyjnej w zależności od wielkości codebase.