Implementieren der ASP.NET-Identität für eine mandantenfähige Anwendung: Best Practices

Das Erstellen einer mehrmandantenfähigen Anwendung stellt besondere Herausforderungen dar, insbesondere wenn es um die Verwaltung der Benutzerauthentifizierung und -autorisierung über mehrere Mandanten hinweg geht. In diesem Artikel erkläre ich Ihnen, wie Sie ASP.NET Identity in einer mandantenfähigen Umgebung implementieren und dabei Best Practices befolgen, um Skalierbarkeit, Sicherheit und Wartbarkeit sicherzustellen.

Was ist eine Multi-Tenant-Anwendung?

Eine mandantenfähige Anwendung ermöglicht es mehreren Organisationen (Mandanten), dieselbe Instanz einer Anwendung zu verwenden, wobei die Daten jedes Mandanten von anderen isoliert sind. Diese Architektur ist effizient für die Skalierung und Kostenteilung, erfordert jedoch besondere Berücksichtigung bei der Benutzerauthentifizierung und -autorisierung.

Einrichten der ASP.NET-Identität für Mehrmandantenfähigkeit

ASP.NET Identity ist ein flexibles Framework für die Authentifizierung und Benutzerverwaltung. Um es für ein Multi-Tenant-Setup anzupassen, müssen Sie Folgendes tun:

1. Identifizieren und unterscheiden Sie Mieter in Ihrem Benutzerspeicher.
2. Benutzerdaten isolieren, sodass jeder Mieter nur seine eigenen Benutzer sieht.
3. Implementieren Sie benutzerdefinierte Authentifizierung und Rollenverwaltungzugeschnitten auf jeden Mandanten.

Schritt 1: Ändern Sie das Benutzermodell, um Mehrmandantenfähigkeit zu unterstützen

In einer mandantenfähigen App muss jeder Benutzer einem bestimmten Mandanten zugeordnet sein. Sie können das ASP.NET Identity User-Modell ändern, indem Sie eine TenantId-Eigenschaft hinzufügen, um den Mandanten zu verfolgen, zu dem ein Benutzer gehört.

public class ApplicationUser : IdentityUser
{
    public string TenantId { get; set; }
}

Schritt 2: IdentityDbContext erweitern, um Mandantendaten zu verarbeiten

Als nächstes erweitern Sie den IdentityDbContext, um mandantenspezifische Daten zu unterstützen, indem Sie sicherstellen, dass Abfragen basierend auf der TenantId gefiltert werden.

public class ApplicationDbContext : IdentityDbContext<ApplicationUser>
{
    public ApplicationDbContext(DbContextOptions<ApplicationDbContext> options)
        : base(options) { }

    protected override void OnModelCreating(ModelBuilder builder)
    {
        base.OnModelCreating(builder);

        // Add a global query filter to isolate data by tenant
        builder.Entity<ApplicationUser>().HasQueryFilter(u => u.TenantId == GetCurrentTenantId());
    }

    private string GetCurrentTenantId()
    {
        // Implement logic to retrieve the current tenant's ID, e.g., from the request or context
        return TenantResolver.ResolveTenantId();
    }
}

Schritt 3: Mieterauflösung

Um sicherzustellen, dass jeder Benutzer dem richtigen Mandanten zugeordnet ist, benötigen Sie einen Mandanten-Resolver, um zu bestimmen, auf welchen Mandanten sich die aktuelle Anfrage bezieht. Dies kann auf der Subdomain, einem URL-Segment oder einem benutzerdefinierten Header basieren.

public static class TenantResolver
{
    public static string ResolveTenantId()
    {
        // Example: Resolve tenant from subdomain or URL segment
        var host = HttpContext.Current.Request.Host.Value;
        return host.Split('.')[0]; // Assuming subdomain is used for tenant identification
    }
}

Schritt 4: Authentifizierung konfigurieren

In einer mandantenfähigen Anwendung muss unbedingt sichergestellt werden, dass sich Benutzer nur mit ihren mandantenspezifischen Anmeldeinformationen authentifizieren können. Passen Sie die Anmeldelogik an, um bei der Authentifizierung nach der TenantId zu suchen.

public class CustomSignInManager : SignInManager<ApplicationUser>
{
    public CustomSignInManager(UserManager<ApplicationUser> userManager,
                               IHttpContextAccessor contextAccessor,
                               IUserClaimsPrincipalFactory<ApplicationUser> claimsFactory,
                               IOptions<IdentityOptions> optionsAccessor,
                               ILogger<SignInManager<ApplicationUser>> logger,
                               IAuthenticationSchemeProvider schemes,
                               IUserConfirmation<ApplicationUser> confirmation)
        : base(userManager, contextAccessor, claimsFactory, optionsAccessor, logger, schemes, confirmation)
    { }

    public override async Task<SignInResult> PasswordSignInAsync(string userName, string password, bool isPersistent, bool lockoutOnFailure)
    {
        // Resolve tenant before signing in
        var tenantId = TenantResolver.ResolveTenantId();
        var user = await UserManager.FindByNameAsync(userName);

        if (user == null || user.TenantId != tenantId)
        {
            return SignInResult.Failed;
        }

        return await base.PasswordSignInAsync(userName, password, isPersistent, lockoutOnFailure);
    }
}

Schritt 5: Rollenbasierte Zugriffskontrolle (RBAC) durch den Mandanten

Jeder Mandant kann über eigene Rollen und Berechtigungen verfügen. Ändern Sie Ihr Rollenmodell, um eine TenantId einzuschließen, und passen Sie die Rollenprüfungen an, um den aktuellen Mandanten zu berücksichtigen.

public class ApplicationRole : IdentityRole
{
    public string TenantId { get; set; }
}

Schritt 6: Sicherer Datenzugriff

Bei mandantenfähigen Anwendungen ist die Datenisolation von entscheidender Bedeutung. Stellen Sie neben der Sicherung der Authentifizierung und Autorisierung sicher, dass Benutzer nur auf mandantenspezifische Daten zugreifen können. Wenden Sie globale Abfragefilter in Ihrem DbContext an oder verwenden Sie Repository-Muster, um Daten basierend auf der aktuellen TenantId zu filtern.

public class UserRepository : IUserRepository
{
    private readonly ApplicationDbContext _context;

    public UserRepository(ApplicationDbContext context)
    {
        _context = context;
    }

    public IQueryable<User> GetUsers()
    {
        var tenantId = TenantResolver.ResolveTenantId();
        return _context.Users.Where(u => u.TenantId == tenantId);
    }
}

Schritt 7: Mehrmandantenfähigkeit testen

Stellen Sie beim Testen einer mandantenfähigen App Folgendes sicher:

• Testen Sie die Anmeldung und Authentifizierung für mehrere Mandanten.
• Stellen Sie sicher, dass Benutzer und Rollen mandantenübergreifend ordnungsgemäß isoliert sind.
• Stellen Sie sicher, dass die Daten nur autorisierten Mietern zugänglich sind.

Mit Unit-Tests und Integrationstests simulieren Sie die Mandantenauflösung und stellen Sie sicher, dass mandantenspezifische Logik angewendet wird.

[TestMethod]
public async Task User_Should_Only_See_Tenant_Data()
{
    // Arrange
    var tenantId = "tenant_1";
    var tenantUser = new ApplicationUser { UserName = "user1", TenantId = tenantId };

    // Act
    var result = await _signInManager.PasswordSignInAsync(tenantUser.UserName, "password", false, false);

    // Assert
    Assert.AreEqual(SignInResult.Success, result);
}

Best Practices-Zusammenfassung

• Benutzer- und Rollendaten isolieren: Stellen Sie sicher, dass Benutzer, Rollen und Berechtigungen auf bestimmte Mandanten beschränkt sind.
• Globale Abfragefilter: Verwenden Sie Abfragefilter, um den Datenzugriff automatisch auf den richtigen Mandanten zu beschränken.
• Mandantenauflösung: Implementieren Sie eine robuste Strategie zur Mandantenauflösung basierend auf Subdomains, URL-Segmenten oder benutzerdefinierten Headern.
• Benutzerdefinierte Authentifizierung: Passen Sie den Authentifizierungsprozess an, um Mieterprüfungen einzubeziehen.
• Gründlich testen: Testen Sie Ihre Anwendung immer in mandantenfähigen Szenarien, um Sicherheits- und Datenlecks zu vermeiden.

Fazit

Die Implementierung von ASP.NET Identity in einer mandantenfähigen Umgebung kann eine Herausforderung sein, aber mit den richtigen Vorgehensweisen können Sie Skalierbarkeit, Sicherheit und Datenisolation gewährleisten. Wenn Sie die in diesem Leitfaden beschriebenen Schritte befolgen, können Sie ein robustes mandantenfähiges Identitätsverwaltungssystem aufbauen, das auf die Bedürfnisse jedes Mandanten zugeschnitten ist.

Let me know if you’ve encountered similar challenges or have other best practices for multi-tenant applications. I'd love to hear your thoughts in the comments!

Das obige ist der detaillierte Inhalt vonImplementieren der ASP.NET-Identität für eine mandantenfähige Anwendung: Best Practices. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!