Applikationsinställningar i ASP.NET Core

Applikationsinställningar används för att konfigurera din applikation i ASP.NET Core. Applikationsinställningar är nyckel-värde-par som kan läsas av konfigurationshanterare. Exempel på konfigurationsvariabler är en anslutningssträng till en databas, en api-slutpunkt eller varaktigheten för data som ska lagras i cacheminnet.

Applikationsinställningarna kan vara olika beroende på i vilken miljö applikationen körs. Inställningarna vid utveckling kan skilja sig från inställningarna som gäller i produktion. Du kan använda olika konfigurationsfiler beroende på miljö eller miljövariabler i din produktionsmiljö (programinställningar i Azure portal till exempel) som skriver över dina utvecklingsinställningar.

Skapa konfiguration

Du måste skapa din konfiguration i ASP.NET Core 1.X och i projekt som inte är webbapplikationer. Användarhemligheter är programinställningar som lagras utanför ditt projekt. Du kan skapa filen secret.json genom att högerklicka på ditt projekt i Visual Studio och klicka på Manage User Secrets (endast webbapplikationer).

public IConfigurationRoot configuration { get; }

public Startup(IHostingEnvironment env)
{
    var builder = new ConfigurationBuilder()
        .SetBasePath(env.ContentRootPath)
        .AddJsonFile("appsettings.json", optional: false, reloadOnChange: true)
        .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true);

    if (env.IsDevelopment())
    {
        builder.AddUserSecrets<Startup>();
    }

    builder.AddEnvironmentVariables(); // Important to set Azure portal variables
    configuration = builder.Build();
}

I den här konfigurationsprocessen kan du se att konfigurationen först byggs från en fil men namnet appsettings.json. Inställningarna kan skrivas över av appsettings.Development.json eller användarhemligheter (secrets.json). Miljövariabler läggs till sist och dessa variabler kan skriva över inställningar från tidigare inlästa filer.

Startpunkt för webbapplikation

När du skapar en ny webbapplikation i ASP.NET Core 2.X behöver du inte skapa någon konfiguration, detta görs automatiskt för dig. Du kan lägga till din egen konfiguration i ConfigureAppConfiguration om du vill, det här är man lägger till inställningar för Azure Key Vault.

public class Program
{
    public static void Main(string[] args)
    {
        CreateWebHostBuilder(args).Build().Run();

    } // End of the main method

    public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>
        WebHost.CreateDefaultBuilder(args)
        .UseApplicationInsights()
        .ConfigureAppConfiguration((context, config) =>
        {
            config.Sources.Clear();
            config.AddJsonFile("myconfig.json", optional: true);
        })
        .UseStartup<Startup>();

} // End of the class

Fil till modell

När konfigurationen är skapad i ditt ASP.NET Core projekt kan du hämta dessa inställningar direkt eller konvertera dem till en modell. Nedan visas ett exempel på en appsettings.json-fil.

{
  "Logging": {
    "IncludeScopes": false,
    "LogLevel": {
      "Default": "Information"
    }
  },
  "FortnoxOptions": {
    "ClientId": "",
    "ClientSecret": "",
    "AuthorizationCode": "",
    "AccessToken": ""
  }
}

Du kan skapa klassen FortnoxOptions för att enkelt kunna konvertera inställningar till modell i klassen StartUp. Om du vill skriva över ClientId i FortnoxOptions som en miljövariabel i Azure portal måste du namnge nyckeln som FortnoxOptions:ClientId.

public class FortnoxOptions
{
    #region Variables

    public string ClientId { get; set; }
    public string ClientSecret { get; set; }
    public string AuthorizationCode { get; set; }
    public string AccessToken { get; set; }

    #endregion

    #region Constructors

    public FortnoxOptions()
    {
        // Set values for instance variables
        this.ClientId = "";
        this.ClientSecret = "";
        this.AuthorizationCode = "";
        this.AccessToken = "";

    } // End of the constructor

    #endregion

} // End of the class

StartUp

Din konfiguration hanteras i klassen StartUp, här konverterar du inställningar till modeller. Nedan visar jag hur man registrerar IOptions genom att hämta enskilda värden från konfigurationen eller genom att konvertera konfiguration till en modell.

public IConfiguration configuration { get; set; }

public Startup(IConfiguration configuration)
{
    this.configuration = configuration;

} // End of the constructor

public void ConfigureServices(IServiceCollection services)
{
    // Add the mvc framework
    services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2);

    // Register options
    services.Configure<FortnoxOptions>(configuration.GetSection("FortnoxOptions"));
    services.Configure<BlobStorageOptions>(configuration.GetSection("BlobStorageOptions"));
    services.Configure<TableStorageOptions>(configuration.GetSection("TableStorageOptions"));
    services.Configure<CacheOptions>(options => { options.ExpirationInMinutes = 240d; });

    // Add redis distributed cache
    if (configuration.GetSection("RedisCacheOptions")["ConnectionString"] != "")
    {
        services.AddDistributedRedisCache(options =>
        {
            options.Configuration = configuration.GetSection("RedisCacheOptions")["ConnectionString"];
            options.InstanceName = "Doxservr:";
        });
    }

} // End of the ConfigureServices method

Azure Key Vault

Du kan använda Azure Key Vault för att lagra programinställningar och certifikat (SSL/TLS). Du måste installera ett NuGet-paket som heter Microsoft.Extensions.Configuration.AzureKeyVault och lägga till dessa inställningar i metoden CreateWebHostBuilder i programklassen.

.ConfigureAppConfiguration((context, config) =>
{
	var builtConfig = config.Build();

	config.AddAzureKeyVault(
		$"https://mysite.vault.azure.net/",
		"ClientId",
		"ClientSecret",
		new KeyVaultSecretManager());
})

Vi har använt en KeyVaultSecretManager-klass för att skapa konfiguration från Azure Key Vault. KeyVault är identifieraren, för att hämta ett konfigurationsvärde behöver du bara ange KeyVault som sektionsnyckel (configuration.GetSection(”KeyVault”)[”A_KEY_IN_AZURE_KEY_VAULT”]).

public class KeyVaultSecretManager : IKeyVaultSecretManager
{
    public bool Load(SecretItem secret)
    {
        return true;
    }

    public string GetKey(SecretBundle secret)
    {
        return $"KeyVault:{secret.SecretIdentifier.Name}";
    }

} // End of the class

Lämna ett svar

E-postadressen publiceras inte. Obligatoriska fält är märkta *