Comment modifier IConfiguration injecté nativement dans Azure Functions

Option 1: apportez la configuration de base avant les autres fournisseurs de configuration

{
    "DbConfig": { "SuperSecretValue": "abc123" }
}

Option 2: Rendez vos dépendances personnalisées plus fines et utilisez IOptions<T>

Au lieu de remplacer l'instance injectée d'IConfiguration ou d'utiliser l'option 1 ci-dessus, rendez vos services en aval dépendants d'un IOptions<T> . Je pense que c'est le meilleur modèle, car vous pouvez diviser votre configuration en petits segments en fonction de vos besoins et faire en sorte que vos services prennent des dépendances plus ciblées.

public class MyService : IMyService
{
    private MyDbConfig _dbConfig;
    public MyService(IOptions<MyDbConfig> myDbConfig)
    {
        _dbConfig = myDbConfig.Value;
    }
}

Dans ce scénario, MyDbConfig est juste un POCO avec des propriétés pour héberger votre configuration. Votre classe de service prend la dépendance sur IOptions<MyDbConfig> :

var configuration = new ConfigurationBuilder()
            .SetBasePath(Directory.GetCurrentDirectory())
            .AddAzureKeyVault(...)
            .AddJsonFile("local.settings.json", true, true)
            .AddEnvironmentVariables()
            .Build();

// don't re-bind IConfiguration
// builder.Services.AddSingleton<IConfiguration>(configuration);

// instead, bind sections specific to what services may need
builder.Services.Configure<MyDbConfig>(config.GetSection("DbConfig"));

Dans les configurations basées sur JSON, vous incluez "DbConfig" (ou tout autre argument que vous fournissez à GetSection ) en tant qu'objet JSON de niveau supérieur, avec vos valeurs de configuration en tant que propriétés dans cet objet:

// ...

var baseConfig = builder.Services.BuildServiceProvider().GetService<IConfiguration>();

var configuration = new ConfigurationBuilder()
    .AddConfiguration(baseConfig)
    .SetBasePath(Directory.GetCurrentDirectory())
    .AddAzureKeyVault(...)
    .AddJsonFile("local.settings.json", true, true)
    .AddEnvironmentVariables()
    .Build();

// ...

Dans KeyVault, vous utilisez -- pour indiquer le modèle d'imbrication, avec un nom secret tel que DbConfig--SuperSecretValue .

Il y a quelques commentaires sur l'utilisation des fonctions Azure .NET Core:

1. Lors de l'exécution locale, local.settings.json est chargé pour vous par défaut par le framework.
2. Vous devez éviter de lire les valeurs de configuration à partir de appsettings.json ou d'autres fichiers, en particulier lors de l'exécution sur le plan de consommation. Documentation sur les fonctions
3. En général, vous devez vous abstenir de passer autour de l'objet IConfiguration . Comme @Dusty l'a mentionné, la méthode IOptions consiste à utiliser le modèle IOptions .
4. Si vous essayez de lire des valeurs à partir d'Azure Key Vault, vous n'avez pas besoin d'ajouter AddAzureKeyVault() car vous pouvez et devez le configurer dans le portail azure à l'aide des références Azure Key Vault. Documents sur Key Vault . En faisant cela, le mécanisme de configuration de la fonction azure ne sait pas / ne se soucie pas où il s'exécute, si vous l'exécutez localement, il se chargera à partir de local.settings.json, s'il est déployé, il obtiendra les valeurs de la configuration de l'application Azure et si vous avez besoin de l'intégration d'Azure Key Vault, tout est effectué via les références Azure Key Vault.
5. Je pense qu'il est également essentiel ici que la configuration des fonctions Azure ne soit pas la même qu'une application .NET traditionnelle qui utilise appsettings.json.
6. La configuration de l'application Azure Functions peut devenir fastidieuse, car vous devez ajouter des paramètres un par un. Nous avons résolu ce problème en utilisant Azure App Configuration. Vous pouvez également le connecter à Azure Key Vault.
7. Application Insights est ajouté automatiquement par Azure Functions. Docs

Cela étant dit, vous pouvez toujours accomplir ce que vous voulez même si ce n'est pas recommandé en procédant comme suit. Gardez à l'esprit que vous pouvez également ajouter les références de coffre-fort de clés dans le code suivant par AddAzureKeyVault()

var configurationBuilder = new ConfigurationBuilder();
var descriptor = builder.Services.FirstOrDefault(d => d.ServiceType == typeof(IConfiguration));
if (descriptor?.ImplementationInstance is IConfiguration configRoot)
{
    configurationBuilder.AddConfiguration(configRoot);
}

// Conventions are different between Azure and Local Development and API
// https://github.com/Azure/Azure-Functions/issues/717
// Environment.CurrentDirectory doesn't cut it in the cloud.
// https://stackoverflow.com/questions/55616798/executioncontext-in-azure-function-iwebjobsstartup-implementation
var localRoot = Environment.GetEnvironmentVariable("AzureWebJobsScriptRoot");
var actualRoot = $"{Environment.GetEnvironmentVariable("HOME")}/site/wwwroot";
var basePath = localRoot ?? actualRoot;
var configuration = configurationBuilder
    .SetBasePath(basePath)
    .AddJsonFile("local.settings.json", optional: true, reloadOnChange: false)
    .AddEnvironmentVariables()
    .Build();

builder.Services.Replace(ServiceDescriptor.Singleton(typeof(IConfiguration), configuration));

Faites-moi savoir si vous avez besoin de plus de commentaires / clarifications à ce sujet et je mettrai à jour ma réponse en conséquence.

Une solution plus simple consisterait à remplacer la méthode ConfigureAppConfiguration dans votre classe FunctionStartup ( https://docs.microsoft.com/en-us/azure/azure-functions/functions-dotnet-dependency-injection#customizing-configuration-sources ).

L'exemple suivant va encore plus loin dans celui fourni dans la documentation en ajoutant des secrets utilisateur.

public override void ConfigureAppConfiguration(IFunctionsConfigurationBuilder builder)
{
    FunctionsHostBuilderContext context = builder.GetContext();

    builder.ConfigurationBuilder
        .SetBasePath(context.ApplicationRootPath)
        .AddJsonFile("appsettings.json", optional: true, reloadOnChange: false)
        .AddJsonFile($"appsettings.{context.EnvironmentName}.json", optional: true, reloadOnChange: false)
        .AddUserSecrets(Assembly.GetExecutingAssembly(), true, true)
        .AddEnvironmentVariables();
}

Par défaut, les fichiers de configuration tels que appsettings.json ne sont pas automatiquement copiés dans le dossier de sortie Azure Function. Assurez-vous de consulter la documentation ( https://docs.microsoft.com/en-us/azure/azure-functions/functions-dotnet-dependency-injection#customizing-configuration-sources ) pour les modifications apportées à votre fichier .csproj . Notez également qu'en raison de la façon dont la méthode ajoute les fournisseurs existants, il est nécessaire de toujours terminer par .AddEnvironmentVariables () .

Une discussion plus approfondie sur la configuration dans une fonction Azure est disponible sur Utilisation de ConfigurationBuilder dans FunctionsStartup