Farewell appsettings.json, welcome Azure App Configuration

As a .NET developer, you’re probably familiar with managing different appsettings.json files for various environments.

But what if I told you there's a better way?

Let's explore how Azure App Configuration can help you move away from environment-specific configuration files.

The Problem with Traditional Configuration

Traditionally, we manage configurations for different environments (development, staging, production) in separate appsettings.json files. This often leads to:

1. Configuration duplication

2. Increased risk of errors when managing multiple files

3. Security challenges: sensitive data like API keys are often stored directly in these files, which are typically checked into version control.

4. Redeployment or restart of your application when there are configuration changes

The Solution: Azure App Configuration

Azure App Configuration provides a centralized service for managing application settings and feature flags. By using this service, we can:

1. Manage configurations per environment

2. Easily modify configurations without new applicational deployments

3. Securely store sensitive information with Azure Key Vault integration

---

Code changes

Nuget Packages

Before we dive into the implementation, make sure you have the following NuGet packages installed in your project:

• Azure.Identity

• Microsoft.Extensions.Configuration.AzureAppConfiguration

You can install these packages using the NuGet Package Manager or by running the following commands in the Package Manager Console:

Install-Package Azure.Identity
Install-Package Microsoft.Extensions.Configuration.AzureAppConfiguration

Extension method

Here’s an example of how you can integrate Azure App Configuration into your .NET application with a useful extension method:

public static class ConfigurationBuilderExtensions
{
    public static IConfigurationBuilder ConfigureAzureAppConfiguration(this IConfigurationBuilder configurationBuilder, string appConfigurationSection)
    {
        var configuration = configurationBuilder.Build();
        var appConfiguration = configuration.GetSection(appConfigurationSection).Get<AppConfigConfiguration>();
        var credentials = GetCredentials();

        configurationBuilder.AddAzureAppConfiguration(options =>
        {
            options.Connect(appConfiguration.Endpoint, credential);
        });

        return configurationBuilder;
    }

    public static ChainedTokenCredential GetCredentials()
     => new(
         new ManagedIdentityCredential(),
         new AzureCliCredential(),
         new AzurePowerShellCredential());
}

Program.cs

To use the extension in your application, you need to add a single line to your Program.cs file. This line should be placed where you're setting up your application's configuration:

builder.Configuration.ConfigureAzureAppConfiguration("AppConfiguration");

Required RBAC Role

It’s important to note that for this to work, the Azure App Service or Azure Container App must have the RBAC role App Configuration Data Reader assigned on the Azure App Configuration resource. This ensures that your application has the necessary permissions to read the configuration data from Azure App Configuration.

One Environment Variable

When using this approach, you only need ONE environment variable. The only environment variable that needs to be added in the Azure App Service or Azure Container App is:

AppConfiguration__Endpoint

The value for this variable should be set to the endpoint of your Azure App Configuration instance https://[YourAppConfigurationName].azconfig.io.

---

How It Works

When your application starts up, the following process occurs:

1. The application reads the AppConfiguration__Endpoint environment variable to get the endpoint of your Azure App Configuration instance.

2. The ConfigureAzureAppConfiguration extension method is called in your Program.cs, which does two important things:
   - It creates a connection to your Azure App Configuration instance using the endpoint and appropriate credentials.
   - It adds a new ConfigurationProvider to your application's configuration system.

3. This new ConfigurationProvider is specifically designed to work with Azure App Configuration. It's added to the configuration pipeline of your application, alongside other providers like environment variables, command-line arguments, or any remaining JSON configuration files.

4. When your application needs to access a configuration value, it goes through all its ConfigurationProviders in order. The Azure App Configuration provider will be able to retrieve values stored in your Azure App Configuration instance.

5. If you’ve set up Azure Key Vault integration, the provider can also seamlessly retrieve secrets stored in Key Vault, providing an extra layer of security for sensitive information.

6. As your application runs, this provider can also handle dynamic updates to your configuration, if you’ve set up that feature. This means your application can receive updated configuration values without needing to restart.

Your application gains a direct line to your centralized configuration in Azure, effectively replacing the need for multiple appsettings.json files or numerous environment variables. This provider acts as a bridge between your application and Azure App Configuration, ensuring that your app always has access to the most up-to-date configuration values.

---

Local development

First of all, make sure you have the App Configuration Data Reader RBAC role assigned on the Azure App Configuration resource.

When developing locally, you need to configure your code to connect to Azure App Configuration. Do this in a secure manner and avoid using an appsettings file. Instead, utilize an environment variable or user secret. More information can be found here.

Environment Variable

If you use an environment variable, add the Azure App Configuration endpoint to the environment variables of your launch profile.

Name: AppConfiguration__Endpoint
Value: https://cfg-dpd-crm-mw-poc.azconfig.io

User Secret

If you use user secrets, add the following to your user secrets file:

{
  "AppConfiguration": {
    "Endpoint": "https://[YourAppConfigurationName].azconfig.io"
  }
}

---

Conclusion

By switching to Azure App Configuration, developers can significantly simplify their configuration management. No more hassle with various appsettings.json files - everything is centrally and securely managed in the cloud.

This approach simplifies your configuration management, makes your application more flexible and able to adapt to configuration changes without redeployment or application restart.

By centralizing your configurations in this way, you’re embracing a more cloud-native approach to application configuration!

---