Azure Functions预生产环境动态获取Azure Key Vault密钥最佳实践

场景描述 #

• 生产环境：ClientId、ClientSecret、SubscriptionKey等密钥为静态值，启动时从配置加载。
• 预生产环境：需在运行时根据请求传入的唯一标识（如GLN）从Azure Key Vault动态获取密钥。

当前实现代码 #

public async Task<Token> GetToken(string identifier)
{
    // Check if the token is cached
    if (_memoryCache.TryGetValue("token", out Token cachedToken) && cachedToken != null)
    {
        return cachedToken;
    }

    Token newToken;

    // Check if running in production (static secrets)
    if (IsProductionEnvironment())
    {
        newToken = await FetchTokenAsync(
            _configuration["ProdClientId"],
            _configuration["ProdClientSecret"],
            _configuration["ProdSubscriptionKey"]);
    }
    else
    {
        // For preproduction, fetch secrets dynamically from Key Vault
        var clientId = await FetchSecretFromKeyVaultAsync($"preprod-{identifier}-clientId");
        var clientSecret = await FetchSecretFromKeyVaultAsync($"preprod-{identifier}-clientSecret");
        var subscriptionKey = await FetchSecretFromKeyVaultAsync($"preprod-{identifier}-subscriptionKey");

        newToken = await FetchTokenAsync(clientId, clientSecret, subscriptionKey);
    }

    // Cache the token
    _memoryCache.Set("token", newToken, new MemoryCacheEntryOptions().SetAbsoluteExpiration(newToken.ExpiresAt));

    return newToken;
}

private async Task<string> FetchSecretFromKeyVaultAsync(string secretName)
{
    // Use KeyVault client to fetch secrets dynamically
    KeyVaultSecret secret = await _secretClient.GetSecretAsync(secretName);
    return secret.Value;
}

问题 #

• 这种基于请求标识动态从Key Vault获取密钥的方式是否为最佳实践？有无更高效的处理方案？
• 如何优化代码结构，避免生产环境静态密钥与预生产环境动态密钥处理的逻辑重复？
• 是否应考虑使用其他Azure服务（如App Configuration）来简化该实现方案？

解答与最佳实践建议 #

1. 动态密钥获取的合理性与效率优化 #

这种动态获取方式在预生产环境是合理的，但可以从以下几点提升效率：

• 批量拉取密钥：当前三次调用Key Vault接口，可改为用GetSecretsAsync批量获取匹配前缀的密钥，减少网络请求次数。
• 缓存密钥而非仅缓存Token：同一标识的密钥不会频繁变更，可将密钥加入缓存（设置1小时左右的过期时间），避免每次请求Token都去Key Vault拉取。
• 区分缓存键：当前固定缓存键"token"会导致不同标识的Token互相覆盖，需改为$"token-{identifier}"，确保每个标识的Token独立缓存。

2. 代码结构优化：消除逻辑重复 #

通过抽象密钥获取逻辑统一生产和预生产的处理流程：

• 定义ISecretProvider接口，封装三类密钥的获取方法；
• 实现两个具体类：ProductionSecretProvider（从配置读取静态值，忽略标识参数）和PreProductionSecretProvider（从Key Vault动态获取并缓存）；
• 启动时根据环境注入对应实现，GetToken方法只需调用统一接口，无需判断环境：

private readonly ISecretProvider _secretProvider;

// 构造函数注入
public YourFunction(ISecretProvider secretProvider, IMemoryCache memoryCache)
{
    _secretProvider = secretProvider;
    _memoryCache = memoryCache;
}

public async Task<Token> GetToken(string identifier)
{
    var cacheKey = $"token-{identifier}";
    if (_memoryCache.TryGetValue(cacheKey, out Token cachedToken) && cachedToken != null)
    {
        return cachedToken;
    }

    var clientId = await _secretProvider.GetClientIdAsync(identifier);
    var clientSecret = await _secretProvider.GetClientSecretAsync(identifier);
    var subscriptionKey = await _secretProvider.GetSubscriptionKeyAsync(identifier);

    var newToken = await FetchTokenAsync(clientId, clientSecret, subscriptionKey);
    _memoryCache.Set(cacheKey, newToken, new MemoryCacheEntryOptions().SetAbsoluteExpiration(newToken.ExpiresAt));

    return newToken;
}

// 接口定义
public interface ISecretProvider
{
    Task<string> GetClientIdAsync(string identifier);
    Task<string> GetClientSecretAsync(string identifier);
    Task<string> GetSubscriptionKeyAsync(string identifier);
}

// 生产环境实现
public class ProductionSecretProvider : ISecretProvider
{
    private readonly IConfiguration _configuration;

    public ProductionSecretProvider(IConfiguration configuration)
    {
        _configuration = configuration;
    }

    public Task<string> GetClientIdAsync(string identifier) => Task.FromResult(_configuration["ProdClientId"]);
    public Task<string> GetClientSecretAsync(string identifier) => Task.FromResult(_configuration["ProdClientSecret"]);
    public Task<string> GetSubscriptionKeyAsync(string identifier) => Task.FromResult(_configuration["ProdSubscriptionKey"]);
}

// 预生产环境实现
public class PreProductionSecretProvider : ISecretProvider
{
    private readonly ISecretClient _secretClient;
    private readonly IMemoryCache _cache;

    public PreProductionSecretProvider(ISecretClient secretClient, IMemoryCache cache)
    {
        _secretClient = secretClient;
        _cache = cache;
    }

    public async Task<string> GetClientIdAsync(string identifier)
    {
        return await GetSecretAsync($"preprod-{identifier}-clientId");
    }

    public async Task<string> GetClientSecretAsync(string identifier)
    {
        return await GetSecretAsync($"preprod-{identifier}-clientSecret");
    }

    public async Task<string> GetSubscriptionKeyAsync(string identifier)
    {
        return await GetSecretAsync($"preprod-{identifier}-subscriptionKey");
    }

    private async Task<string> GetSecretAsync(string secretName)
    {
        var cacheKey = $"secret-{secretName}";
        if (_cache.TryGetValue(cacheKey, out string cachedSecret))
        {
            return cachedSecret;
        }

        var secret = await _secretClient.GetSecretAsync(secretName);
        var secretValue = secret.Value;
        _cache.Set(cacheKey, secretValue, new MemoryCacheEntryOptions().SetAbsoluteExpiration(TimeSpan.FromHours(1)));
        return secretValue;
    }
}

3. Azure App Configuration的使用建议 #

可以结合App Configuration简化实现：

• 在App Configuration中为不同环境配置密钥规则：生产环境存储Key Vault引用（避免明文），预生产环境配置密钥名称模板（如preprod-{0}-clientId）；
• 利用App Configuration的动态刷新功能，无需重启Function即可更新配置；
• 通过App Configuration与Key Vault的集成，直接从配置中获取密钥，无需手动调用Key Vault客户端，进一步简化代码。

额外最佳实践 #

• 权限最小化：确保Azure Function的托管标识对Key Vault仅拥有Secret Get权限，避免过度授权；
• 错误重试：用Polly等库为Key Vault请求添加重试逻辑，处理临时网络故障或限流；
• 安全日志：记录密钥获取的成功/失败状态，但禁止记录密钥明文。

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