Learn Cloud-Native .NET: Core Configuration Fundamentals with Steeltoe

.NET Core: Conﬁguration
Fundamentals
David Dieruf - Pivotal
July, 2019

Let's Talk About...
Cloud-native environment and goals
Why we are here
Designing config and environment variables
Different patterns
About .NET Core configuration
Building config providers in WebHost and its hierarchy of values
The options pattern
Extending basic config with objects
External configuration servers
How they work and why you choose them
Putting the pieces together
Using Steeltoe and Spring Config to reach cloud-native goals

Environment: Local
Network
Services: DB, Cache, SMB
Environment: Stage Environment: Prod
Team Foundation Server (CI/CD): Git, Build, Release
My-App
Network
Network
My-App My-App
- One build
- Test once (for all environments)
- Parity between environments
- Automation
My-App My-App
public void ConfigureServices(IServiceCollection services) {
String connString = Environment.GetEnvironmentVariable("conn_string");
services.AddDbContext<MyContext>(options => options.UseSqlServer(connString));
}

Environment variables in the cloud
How is the value set?
Do you have to manually update the value per
instance, or script the action?
How easy is promotion?
Do you have to recompile to move between
environments? Does your build pipeline manipulate
settings?
Do you have a history of changes?
Do you know when a value was set and by who?
Atomic value in the
cloud
Per app instance
App can not run without
a value
Agnostic to its platform
or IaaS (portable)

Appsettings.json
● [Good] External to the
compiled application
● [Good] No recompilation
needed
● [Challenge] Have to change
at every instance
Internal Class Command Line
● [Good] Secure information
in compiled bits
● [Challenge] Hard coded
values in app
● [Challenge] Can not change
without recompiling
at every instance
● [Challenge] Lost values
because no source check-in
(Manual)
Environment Variables
Popular Conﬁguration Design
● [Good] Application
compiled once and
promoted through
environment
at every host
class MyClass {
string connString = "xxxx"
}
{
"ConnectionStrings": {
"a-database": "xxxxx"
}
}
C: dotnet run my-app `
--conn "xxxx" `
--something "yyyyy"
string connString =
Environment.GetEnvironmentVari
able("my-conn")

https://docs.microsoft.com/en-us/aspnet/core/fundamentals/conﬁguration
.NET Core Conﬁguration

Using Default
WebHost
Loading conﬁguration into your app
public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>
WebHost.CreateDefaultBuilder(args)
.UseStartup<Startup>();
- use Kestrel as the web server and configure it using the
application's configuration providers
- set the ContentRootPath to the result of GetCurrentDirectory()
- load IConfiguration from 'appsettings.json' and
'appsettings.[EnvironmentName].json'
- load IConfiguration from User Secrets when EnvironmentName
is 'Development' using the entry assembly
- load IConfiguration from environment variables
- load IConfiguration from supplied command line args
- configure the ILoggerFactory to log to the console and debug
output
- enable IIS integration
program.cs

Build your own
WebHost
Loading conﬁguration into your app
public static IWebHost BuildWebHost(string[] args) {
var builder = new WebHostBuilder()
.UseKestrel()
.UseContentRoot(Directory.GetCurrentDirectory())
.ConfigureAppConfiguration((hostingContext, config) => {
var env = hostingContext.HostingEnvironment;
config.AddJsonFile("appsettings.json")
.AddJsonFile($"appsettings.{env.EnvironmentName}.json",
optional: true);
config.AddEnvironmentVariables();
config.AddCommandLine(args);
})
.UseIISIntegration()
.UseStartup<Startup>();
return builder.Build();
}
program.cs
- Options manipulate how configuration values are overwritten
- Options to [not] include other configuration providers, like
custom external config server provider

Conﬁg value
hierarchy
Overwrite values based on
environment
...
.AddJsonFile($"appsettings.{env.EnvironmentName}.json");
})
...
1. Load values from appsettings.json
2. (if provided) Load values from environment
specific appsettings.{env}.json
3. (if present) Load values from environment
variables
4. (if present) Load values provided when app
was started
.AddJsonFile($"appsettings.{env.EnvironmentName}.json");

{
"my_val": "something"
}
Example Value Overwriting
1. config.AddJsonFile("appsettings.json")
{
"my_val": "another"
}
2. .AddJsonFile("appsettings.staging.json")
PS c: $env:my_val = "yet another"
3. config.AddEnvironmentVariables()
PS c: dotnet run my-app --my_val "again another"
4. config.AddCommandLine(args)
my_val == “again another”

Conﬁguration
Providers
Supported providers for
conﬁguration of ASP.NET core app
Provider
Provides configuration
from…
Azure Key Vault Configuration Provider (Security topics) Azure Key Vault
Azure App Configuration Provider (Azure documentation) Azure App Configuration
Command-line Configuration Provider Command-line parameters
Custom configuration provider Custom source
Environment Variables Configuration Provider Environment variables
File Configuration Provider Files (INI, JSON, XML)
Key-per-file Configuration Provider Directory files
Memory Configuration Provider In-memory collections
User secrets (Secret Manager) (Security topics) File in the user profile directory

Consuming
Values
Using
Microsoft.Extensions.Conﬁguration
public class ValuesController : Controller{
private readonly IConfiguration _config;
public ValuesController(IConfiguration config){
_config = config;
}
[HttpGet]
public ActionResult<string> Get(){
string val = _config.GetValue<string>("my_val");
return val;
}
}
- No consideration for handler type(s)
- Simple key:value store
- Can be complex type
ValuesController.cs

https://docs.microsoft.com/en-us/aspnet/core/fundamentals/conﬁguration/options
Options Pattern

Options Pattern Using Microsoft.Extensions.Conﬁguration.Options
{
"section0": {
"key0": "value",
"key1": "value"
},
"section1": {
"key0": "value",
"key1": "value"
}
}
services.AddOptions();
services.Configure<SectionZeroOptions>(Configuration.GetSection("section0"));
...
}
public class SectionZeroOptions {
public string key0 {get;set;}
public string key1 { get; set; }
}
public class MyService : IMyService {
private IOptions<SectionZeroOptions> _SectionZeroOptions;
public MyService(IOptions<SectionZeroOptions> sectionZeroOptions) {
_SectionZeroOptions = sectionZeroOptions;
}
public string DoSomething(){
string key0 = _SectionZeroOptions.Value.key0;
return key0;
}
}
1. appsettings.json values
2. Matching class to json
3. Enable the Options conﬁguration
4. Consume values
{
"section0": {
"key0": "value",
"key1": "value"
},
"section1": {
"key0": "value",
"key1": "value"
}
}
public class SectionZeroOptions {
public string key0 {get;set;}
public string key1 { get; set; }
}
services.Configure<SectionZeroOptions>(Configuration.GetSection("section0"));
...
}
public class MyService : IMyService {
private IOptions<SectionZeroOptions> _SectionZeroOptions;
public MyService(IOptions<SectionZeroOptions> sectionZeroOptions) {
_SectionZeroOptions = sectionZeroOptions;
}
public string DoSomething(){
return key0;
}
}

Business Case using options pattern
You have an api that is responsible for approving loans. There are
business rules within the app that need to be applied, to decide
approval. One of those rules compares the loan amount being asked
for, to a max loan amount the business is willing to approve. The max
amount changes throughout the year based on other events.
Place the max approval amount (integer) in an external conﬁg and give
yourself the ﬂexibility to change values at any moment, with no
downtime.

External Conﬁguration Server
Custom conﬁguration provider

About Config
Server
At boot time…
➔ Platform puts values in environment variables
➔ Client looks for server
➔ Client gets config by NAME
➔ Config organised by PROFILE
At runtime...
➔ Config can be refreshed live
➔ Call /actuator/refresh
➔ Values get reloaded
➔ No need for restart!

Environment: Stage Environment: ProdEnvironment: Local
Network
Team Foundation Server (CI/CD): Git, Build, Release
Network
Network
Conﬁg Server: development.yml, staging.yml, production.yml
string connString = Environment.GetEnvironmentVariable("conn_string");
string configUri = Environment.GetEnvironmentVariable("config_uri");

Simplicity vs Flexibility
External configuration can be challenging in itself It offers so much
design options that things can get out of hand quickly. Use the domain
around you to decide how far to go.
Config First Approach
Don’t hold anything in your appsettings.json, only a pointer to the
config server. Everything is filled from there.

Steeltoe and Spring Conﬁg
Putting the pieces together

2. Set the application Name (in appsettings.json)...
Setup Configuration Client: .NET / Steeltoe / Spring Config
4. Include the custom config provider...
1: Add the dependencies...
(Steeltoe for Pivotal Spring Cloud Config Client)
3. Add your external configuration (in Git)...
"spring": {
"application": { "name": "loan-application-service" },
"cloud": {
"config": {
"uri": "http://10.0.7.254:8888",
"validate_certificates": false,
"fail_fast": true
...
<PackageReference
Include="Steeltoe.Extensions.Configuration.ConfigServerCore" ... />
public void ConfigureServices(IServiceCollection services){
services.Configure<Services.SomeValuesOptions>
(Configuration.GetSection("SomeValues"));
services.AddMvc();
...
}
.ConfigureAppConfiguration((hostingContext, config) =>{
ILoggerFactory fac = GetLoggerFactory(hostingContext.HostingEnvironment);
config.AddConfigServer(env, fac);
})
...
public class SomeValuesOptions {
public string scheme { get; set; }
public string address { get; set; }
}
program.cs
startup.cs
config options pattern
Logging:
IncludeScopes: false
Debug:
LogLevel:
Default: Information
SomeValues:
scheme: https
address: www.pivotal.io
5. Retrieve values and map to class...
<PackageReference
Include="Steeltoe.Extensions.Configuration.ConfigServerCore" ... />
"spring": {
"application": { "name": "loan-application-service" },
"cloud": {
"config": {
"uri": "http://127.0.0.1:8888",
"validate_certificates": false,
"fail_fast": true
...
Logging:
IncludeScopes: false
Debug:
LogLevel:
Default: Information
SomeValues:
scheme: https
address: www.pivotal.io
.ConfigureAppConfiguration((hostingContext, config) =>{
ILoggerFactory fac = GetLoggerFactory(hostingContext.HostingEnvironment);
})
...
public void ConfigureServices(IServiceCollection services){
services.Configure<Services.SomeValuesOptions>
(Configuration.GetSection("SomeValues"));
services.AddMvc();
...
}
public class SomeValuesOptions {
public string scheme { get; set; }
public string address { get; set; }
}
"name": "loan-application-service"
"uri": "http://127.0.0.1:8888"

© Copyright 2019 Pivotal Software, Inc. All rights Reserved.
Learn More.
Become a cloud-native .NET rock star
https://springoneplatform.io/2019/training
Pivotal Platform Acceleration Lab for Developers (.NET)
Experience best practices building cloud-native applications in
a hands-on setting with Pivotal educators and consultants. The
program is focused on enabling customers and partners
through “doing it” rather than “talking about it”.
https://pivotal.io/platform-acceleration-lab

Refreshing
Values
- Optionally provide an environment specific
json config
Startup.cs
...
config.AddJsonFile("appsettings.json",
reloadOnChange: true)
optional: true, reloadOnChange: true);
})
...

Optional
providers
- Optionally provide an environment specific
json config
Startup.cs
...
optional: true);
})
...

Learn Cloud-Native .NET: Core Configuration Fundamentals with Steeltoe

More Related Content

What's hot (19)

Similar to Learn Cloud-Native .NET: Core Configuration Fundamentals with Steeltoe (20)

More from VMware Tanzu (20)

Recently uploaded (20)

Learn Cloud-Native .NET: Core Configuration Fundamentals with Steeltoe