Configuration Service

Package	Latest Release
ConfigurationService.Hosting
ConfigurationService.Client

About Configuration Service

Configuration Service is a remote configuration service for .NET Core. 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 either git or a file system and supports publishing changes with Redis or RabbitMQ publish/subscribe. File types supported are .json, .yaml, .xml and .ini.

Features

• RESTful HTTP based API for external configuration.
• Server easily integrates into an ASP.NET Core 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 and file system based storage.
• Support for .json, .yaml, .xml and .ini configuration files.
• Inject configuration with IOptionsMonitor or IOptionsSnapshot to access configuration changes.

Installing with NuGet

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

Adding the Configuration Service Host

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

public void ConfigureServices(IServiceCollection services)
{
    services.AddControllers();

    services.AddConfigurationService()
        .AddGitProvider(c =>
        {
            c.RepositoryUrl = "https://example.com/my-repo/configuration.git";
            c.Username = "username";
            c.Password = "password";
            c.LocalPath = "C:/config";
        })
        .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.

Git Provider Options

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

File System Provider Options

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

Custom Storage Providers and Publishers

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()
    .AddCustomProvider(new CustomStorageProvider())
    .AddCustomPublisher(new CustomPublisher());

Adding the Configuration Service Client

The Configuration Service client can be configured by adding AddRemoteSource 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 the configuration.

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

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

configuration = new ConfigurationBuilder()
    .AddConfiguration(configuration)
    .AddRemoteSource(s => 
    {
        s.ConfigurationName = "text.json";
        s.ConfigurationServiceUri = "http://localhost:5000/configuration/";
        s.Subscriber = () => new RedisSubscriber("localhost:6379");
        s.Optional = false;
        s.ReloadOnChange = true;
        s.LoggerFactory = loggerFactory;
    })
    .Build();

Configuration Soruce Options

Samples

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