Read JSON Files from Azure App Configuration

This post walks through the steps of reading JSON files from Azure App Configuration, complete with explanations and code samples.

Modern cloud applications often rely on configuration management systems to centralize and secure application settings. Azure App Configuration is one such service that allows developers to store and manage configurations separately from code. A common use case is reading JSON files—such as feature flags, settings, or structured data—from App Configuration into your application.

Why Use Azure App Configuration for JSON?

JSON is widely used for structured data in applications. Storing JSON in Azure App Configuration provides:

Centralized Management – Manage configuration in one place across multiple environments.
Dynamic Refresh – Update configurations without redeploying applications.
Security – Integrates with Azure security controls, including role-based access.
Versioning and Labels – Maintain different versions of your configuration files.

Store JSON in Azure App Configuration

You can store a JSON file in Azure App Configuration as a key-value pair. Typically, the key represents the configuration name, and the value holds the JSON content.

Example:

Key: AppSettings:FeatureConfig

Value:

{
  "FeatureA": true,
  "FeatureB": false,
  "MaxItems": 100
}

You can add this via the Azure Portal, Azure CLI, or an ARM/Bicep template.

Azure CLI Example:

az appconfig kv set \
  --name <AppConfigName> \
  --key "AppSettings:FeatureConfig" \
  --value '{"FeatureA": true, "FeatureB": false, "MaxItems": 100}' \
  --label "prod"

Connect Application to Azure App Configuration

First, install the necessary NuGet packages in your .NET application:

dotnet add package Microsoft.Extensions.Configuration.AzureAppConfiguration

Update your Program.cs or Startup.cs to connect to Azure App Configuration.

Program.cs Example:

var builder = WebApplication.CreateBuilder(args);

// Add Azure App Configuration
builder.Configuration.AddAzureAppConfiguration(options =>
{
    options.Connect("<Connection-String>")
           .Select("AppSettings:*");
});

var app = builder.Build();

app.MapGet("/", (IConfiguration config) =>
{
    var featureConfig = config.GetSection("AppSettings:FeatureConfig").Get<FeatureConfig>();
    return Results.Json(featureConfig);
});

app.Run();

public class FeatureConfig
{
    public bool FeatureA { get; set; }
    public bool FeatureB { get; set; }
    public int MaxItems { get; set; }
}

Deserialize JSON Configuration

When retrieving JSON values from App Configuration, you’ll often want to deserialize them into strongly typed objects.

Here is the missing code to deserialize:

var jsonConfig = builder.Configuration["AppSettings:FeatureConfig"];
var featureConfig = JsonSerializer.Deserialize<FeatureConfig>(jsonConfig);

This approach gives you a strongly typed object that you can use throughout your application.

Enable Dynamic Refresh (Optional)

One of the biggest advantages of Azure App Configuration is dynamic refresh. It allows your application to pick up configuration changes without redeployment.

Program.cs Example with Refresh:

builder.Configuration.AddAzureAppConfiguration(options =>
{
    options.Connect("<Connection-String>")
           .ConfigureRefresh(refresh =>
           {
               refresh.Register("AppSettings:FeatureConfig", refreshAll: true);
           });
});

In addition, register middleware:

builder.Services.AddAzureAppConfiguration();
var app = builder.Build();
app.UseAzureAppConfiguration();

This ensures your application automatically reloads configuration updates.

Use Labels for Environment-Specific JSON

Labels in Azure App Configuration allow you to differentiate settings for environments like dev, test, and prod.

Example:

az appconfig kv set \
  --name <AppConfigName> \
  --key "AppSettings:FeatureConfig" \
  --value '{"FeatureA": true, "FeatureB": true, "MaxItems": 50}' \
  --label "dev"

When connecting, specify the label:

builder.Configuration.AddAzureAppConfiguration(options =>
{
    options.Connect("<Connection-String>")
           .Select("AppSettings:*", labelFilter: "dev");
});

Best Practices

Keep JSON Compact – Avoid overly large JSON objects to reduce latency.
Use Strongly Typed Objects – Deserialize JSON into C# objects for safer usage.
Secure Access – Use managed identity instead of connection strings for production.
Version with Labels – Always tag configurations with labels to avoid confusion across environments.

Conclusion

Reading JSON files from Azure App Configuration streamlines how you manage structured data across applications. By centralizing configuration, enabling dynamic refresh, and leveraging labels for environment-specific settings, you gain both flexibility and control. Using strongly typed deserialization ensures your app handles configurations safely and predictably.

With this approach, your applications are more maintainable, secure, and responsive to configuration changes without requiring redeployment.

Discover more from CPI Consulting

Subscribe to get the latest posts sent to your email.