Package	Latest Release
ConfigurationService.Hosting
ConfigurationService.Client

Configuration Service is a distributed configuration service for .NET. Configuration for fleets of applications, services, and containerized micro-services can be updated immediately without the need to redeploy or restart. Configuration Service uses a client/server pub/sub architecture to notify subscribed clients of configuration changes as they happen. Configuration can be injected using the standard options pattern with IOptions, IOptionsMonitor or IOptionsSnapshot.

Configuration Service currently supports hosting configuration with git, file system or Vault backends and supports publishing changes with Redis, NATS or RabbitMQ publish/subscribe. File types supported are .json, .yaml, .xml and .ini.

• RESTful HTTP based API for external configuration.
• Server easily integrates into an ASP.NET application.
• Client easily integrates into any .NET Standard 2.0 application using the standard ConfigurationBuilder pattern.
• Client encapsulates real-time configuration updates.
• Support for git, file system and Vault backend storage.
• Support for pub/sub with Redis, NATS and RabbitMQ.
• Support for .json, .yaml, .xml and .ini configuration files.
• Inject configuration with IOptionsMonitor or IOptionsSnapshot to access configuration changes.

The easiest way to install Configuration Service is with NuGet.

In Visual Studio's Package Manager Console, enter the following command:

Server:

Install-Package ConfigurationService.Hosting

Client:

Install-Package ConfigurationService.Client

The Configuration Service host middleware can be added to the service collection of an existing ASP.NET application. The following example configures a git storage provider with a Redis publisher.

builder.Services.AddConfigurationService()
    .AddGitProvider(c =>
    {
        c.RepositoryUrl = "https://github.com/jamespratt/configuration-test.git";
        c.LocalPath = "C:/local-repo";
    })
    .AddRedisPublisher("localhost:6379");

In Startup.Configure, call MapConfigurationService on the endpoint builder. The default pattern is "/configuration".

app.UseEndpoints(endpoints =>
{
    endpoints.MapConfigurationService();
});

The configured host will expose two API endpoints:

• configuration/ - Lists all files at the configured provider.
• configuration/{filename} - Retrieves the contents of the specified file.

services.AddConfigurationService()
    .AddGitProvider(c =>
    {
        c.RepositoryUrl = "https://example.com/my-repo/my-repo.git";
        c.Username = "username";
        c.Password = "password";
        c.Branch = "main";
        c.LocalPath = "C:/config";
        c.SearchPattern = ".*json";
        c.PollingInterval = TimeSpan.FromSeconds(60);
    }
    ...

services.AddConfigurationService()
    .AddFileSystemProvider(c => 
    {
        c.Path = "C:/config";
        c.SearchPattern = "*.json";
        c.IncludeSubdirectories = true;
    })
    ...

services.AddConfigurationService()
    .AddVaultProvider(c =>
    {
        c.ServerUri = "http://localhost:8200/";
        c.Path = "secret/";
        c.AuthMethodInfo = new TokenAuthMethodInfo("myToken");
    })
    ...

Custom implementations of storage providers and publishers can be added by implementing the IProvider and IPublisher interfaces and calling the appropriate extension methods on AddConfigurationService:

services.AddConfigurationService()
    .AddProvider(new CustomStorageProvider())
    .AddPublisher(new CustomPublisher());

The Configuration Service client can be configured by adding AddRemoteConfiguration to the standard configuration builder. In the following example, remote json configuration is added and a Redis endpoint is specified for configuration change subscription. Local configuration can be read for settings for the remote source by using multiple instances of configuration builder.

var loggerFactory = LoggerFactory.Create(builder =>
{
    builder.AddConsole();
});

IConfiguration configuration = new ConfigurationBuilder()
    .AddJsonFile("appsettings.json", optional: false, reloadOnChange: true)
    .Build();

configuration = new ConfigurationBuilder()
    .AddConfiguration(configuration)
    .AddRemoteConfiguration(o =>
    {
        o.ServiceUri = "http://localhost:5000/configuration/";
        o.AddConfiguration(c =>
        {
            c.ConfigurationName = "test.json";
            c.ReloadOnChange = true;
            c.Optional = false;
        });
        o.AddConfiguration(c =>
        {
            c.ConfigurationName = "test.yaml";
            c.ReloadOnChange = true;
            c.Optional = false;
            c.Parser = new YamlConfigurationFileParser();
        });
        o.AddRedisSubscriber("localhost:6379");
        o.AddLoggerFactory(loggerFactory);
    })
    .Build();

Samples of both host and client implementations can be viewed at Samples.