如何在.NET Core 7多租户WebAPI中实现动态JWT密钥验证？

针对你的多租户场景（每个租户独立数据库），要实现动态专属JWT密钥且避免每次请求查库，推荐以下几种可行方案，按实用性排序：

一、核心方案：租户密钥缓存+按需刷新 #

这是最常用的平衡性能与动态性的方案，核心思路是将租户密钥缓存到内存/分布式缓存，仅在缓存失效或不存在时查询数据库，同时支持主动刷新。

关键步骤： #

1. 搭建共享元数据库
   必须单独维护一个共享的元数据库（而非每个租户的独立库），存储所有租户的基础配置：

   • 租户ID（唯一标识）
   • 加密后的JWT密钥（禁止明文存储）
   • 密钥更新时间（用于缓存刷新判断）
   • 租户数据库连接字符串等其他元信息

2. 实现缓存逻辑
   使用.NET Core自带的IMemoryCache或分布式缓存（如Redis），缓存键设计为TenantKey_{TenantId}，设置合理的过期时间（比如1小时）。同时提供两种刷新机制：

   • 被动刷新：缓存失效时自动从元数据库拉取最新密钥并更新缓存
   • 主动刷新：提供管理员API，当租户密钥更新时手动触发缓存刷新（比如调用cache.Remove(cacheKey)）

3. 自定义JWT密钥解析逻辑
   在AddJwtBearer配置中，通过IssuerSigningKeyResolver动态获取对应租户的密钥，示例代码：

// 注入缓存和租户配置仓储
builder.Services.AddScoped<ITenantConfigRepository, TenantConfigRepository>();
builder.Services.AddMemoryCache();

builder.Services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
    .AddJwtBearer(options =>
    {
        options.TokenValidationParameters = new TokenValidationParameters
        {
            ValidateIssuer = true,
            ValidateAudience = true,
            ValidateLifetime = true,
            ValidateIssuerSigningKey = true,
            ValidIssuer = builder.Configuration["Jwt:Issuer"],
            ValidAudience = builder.Configuration["Jwt:Audience"],
            // 自定义密钥解析器
            IssuerSigningKeyResolver = async (token, securityToken, kid, validationParameters) =>
            {
                var jwtHandler = new JwtSecurityTokenHandler();
                var jwtToken = jwtHandler.ReadJwtToken(token);
                
                // 从JWT Claim中提取租户ID（生成Token时需写入该Claim）
                var tenantId = jwtToken.Claims.FirstOrDefault(c => c.Type == "TenantId")?.Value;
                if (string.IsNullOrEmpty(tenantId)) return null;

                var cache = builder.Services.BuildServiceProvider().GetRequiredService<IMemoryCache>();
                var tenantRepo = builder.Services.BuildServiceProvider().GetRequiredService<ITenantConfigRepository>();
                var cacheKey = $"TenantKey_{tenantId}";

                // 先从缓存取密钥
                if (!cache.TryGetValue(cacheKey, out string? key))
                {
                    // 缓存不存在时从元数据库查询（注意密钥需解密）
                    var tenantConfig = await tenantRepo.GetTenantConfigAsync(tenantId);
                    if (tenantConfig == null) return null;
                    
                    // 这里假设存储的是加密后的密钥，需解密
                    key = DecryptKey(tenantConfig.EncryptedKey);
                    
                    // 更新缓存，设置1小时过期
                    cache.Set(cacheKey, key, TimeSpan.FromHours(1));
                }

                return new List<SecurityKey> { new SymmetricSecurityKey(Encoding.UTF8.GetBytes(key!)) };
            }
        };
    });

4. Token生成逻辑
   生成Token时，需将TenantId写入Claim，并使用该租户的密钥签名：

public async Task<string> GenerateTenantToken(string tenantId, string userId)
{
    var tenantConfig = await _tenantRepo.GetTenantConfigAsync(tenantId);
    var key = DecryptKey(tenantConfig.EncryptedKey);
    var securityKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(key));
    var credentials = new SigningCredentials(securityKey, SecurityAlgorithms.HmacSha256);

    var claims = new[]
    {
        new Claim(JwtRegisteredClaimNames.Sub, userId),
        new Claim("TenantId", tenantId),
        new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString())
    };

    var token = new JwtSecurityToken(
        issuer: _config["Jwt:Issuer"],
        audience: _config["Jwt:Audience"],
        claims: claims,
        expires: DateTime.Now.AddHours(1),
        signingCredentials: credentials);

    return new JwtSecurityTokenHandler().WriteToken(token);
}

二、备选方案：预加载密钥到内存（适合租户数量少的场景） #

如果你的租户数量不多（比如几十家以内），可以在应用启动时一次性从元数据库拉取所有租户的密钥到内存，然后定时刷新（比如每小时拉取一次）。这种方式完全避免请求时查库，性能最优。

示例启动逻辑：

var app = builder.Build();

// 应用启动时预加载租户密钥到内存
using (var scope = app.Services.CreateScope())
{
    var tenantRepo = scope.ServiceProvider.GetRequiredService<ITenantConfigRepository>();
    var cache = scope.ServiceProvider.GetRequiredService<IMemoryCache>();
    
    var allTenants = await tenantRepo.GetAllTenantConfigsAsync();
    foreach (var tenant in allTenants)
    {
        var key = DecryptKey(tenant.EncryptedKey);
        cache.Set($"TenantKey_{tenant.TenantId}", key, TimeSpan.FromHours(1));
    }
}

// 可选：用定时任务定期刷新缓存（比如用Hangfire）
// RecurringJob.AddOrUpdate(() => RefreshTenantKeys(), Cron.Hourly);

三、高级方案：使用密钥管理服务（KMS） #

如果对密钥安全性要求极高，可将租户密钥存储到专业的KMS服务（如Azure Key Vault、AWS KMS），通过租户ID作为密钥名称来获取密钥。同时在本地缓存KMS的查询结果，减少KMS调用次数。这种方案自带密钥加密、权限控制、审计日志等功能，但依赖云服务或自建KMS。

注意事项： #

• 密钥加密存储：无论用哪种方案，密钥都不能明文存储在数据库，必须用对称加密（如AES）或非对称加密存储，取用时解密。
• 租户ID的可靠性：确保TenantID的来源不可篡改，优先从JWT Claim中获取（因为Token本身已签名），避免从请求头/路由参数直接获取（易被篡改）。
• 缓存一致性：当租户密钥更新时，要及时清空对应缓存，避免使用旧密钥验证Token。

内容的提问来源于stack exchange，提问作者GeorgeArrays