Alkalmazáskonfiguráció

Jótanács

Ez a tartalom egy részlet az eBookból, Blazor az Azure-hoz készült ASP NET Web Forms Developers számára, amely elérhető a .NET Docs-on vagy egy ingyenesen letölthető PDF-fájlként, amely offline is olvasható.

PDF letöltése

Az alkalmazáskonfiguráció webes űrlapokban való betöltésének elsődleges módja a web.config fájl bejegyzései – akár a kiszolgálón, akár a web.configáltal hivatkozott kapcsolódó konfigurációs fájlban. A statikus ConfigurationManager objektummal kezelheti az alkalmazásbeállításokat, az adattár kapcsolati sztringeit és az alkalmazásba felvett egyéb kiterjesztett konfigurációs szolgáltatókat. Az alkalmazáskonfigurációval való interakciók általában az alábbi kódban láthatók:

var configurationValue = ConfigurationManager.AppSettings["ConfigurationSettingName"];
var connectionString = ConfigurationManager.ConnectionStrings["MyDatabaseConnectionName"].ConnectionString;

Az ASP.NET Core és a kiszolgálóoldali Blazor esetében a web.config fájl jelenhet meg, ha az alkalmazás Windows IIS-kiszolgálón van üzemeltetve. Ezzel a konfigurációval azonban nincs ConfigurationManager interakció, és más forrásokból is kaphat strukturáltabb alkalmazáskonfigurációt. Nézzük meg, hogyan van összegyűjtve a konfiguráció, és hogyan férhet még mindig hozzá a konfigurációs információkhoz egy web.config fájlból.

Konfigurációs források

ASP.NET Core felismeri, hogy számos konfigurációs forrást érdemes használni az alkalmazáshoz. A keretrendszer alapértelmezés szerint megpróbálja a legjobbat nyújtani ezek közül a funkciók közül. A konfigurációt a ASP.NET Core olvassa és összesíti ezekből a különböző forrásokból. Ugyanahhoz a konfigurációs kulcshoz később betöltött értékek elsőbbséget élveznek a korábbi értékekkel szemben.

ASP.NET Core úgy lett kialakítva, hogy felhőtudatos legyen, és megkönnyítse az alkalmazások konfigurálását mind az operátorok, mind a fejlesztők számára. ASP.NET Core környezettudatos, és tudja, hogy az Ön Production vagy Development a környezetében fut-e. A környezeti jelző a ASPNETCORE_ENVIRONMENT rendszer környezeti változójában van beállítva. Ha nincs konfigurálva érték, az alkalmazás alapértelmezés szerint a Production környezetben fut.

Az alkalmazás több forrásból is aktiválhat és adhat hozzá konfigurációt a környezet neve alapján. Alapértelmezés szerint a konfiguráció a következő erőforrásokból töltődik be a felsorolt sorrendben:

1. appsettings.json fájl, ha van
2. appsettings.{ENVIRONMENT_NAME}.json fájl, ha van ilyen
3. Felhasználó titkos fájlja lemezen, ha van ilyen
4. Környezeti változók
5. Parancssori paraméterek

appsettings.json formátum és hozzáférés

A appsettings.json fájl hierarchikus lehet az alábbi JSON-értékekkel:

{
  "section0": {
    "key0": "value",
    "key1": "value"
  },
  "section1": {
    "key0": "value",
    "key1": "value"
  }
}

Amikor bemutatják az előző JSON-t, a konfigurációs rendszer laposítja az alértékeket, és hivatkozik azok teljesen minősített hierarchikus útvonalaira. A kettőspont (:) karakter elválasztja a hierarchia minden tulajdonságát. A konfigurációs kulcs section1:key0 például hozzáfér az section1 objektumkonstans értékéhez key0 .

Felhasználói titkos kódok

A felhasználói titkos kódok a következők:

• A fejlesztői munkaállomáson, az alkalmazásfejlesztési mappán kívüli JSON-fájlban tárolt konfigurációs értékek.
• Csak akkor töltődik be, ha a Development környezetben fut.
• Adott alkalmazáshoz társítva.
• A .NET CLI user-secrets parancsával kezelve.

Konfigurálja az alkalmazást titkos kulcsok tárolására a user-secrets parancs végrehajtásával:

dotnet user-secrets init

Az előző parancs hozzáad egy UserSecretsId elemet a projektfájlhoz. Az elem tartalmaz egy GUID azonosítót, amellyel titkos kulcsokat társíthat az alkalmazáshoz. Ezután definiálhat egy titkos kulcsot a set paranccsal. Például:

dotnet user-secrets set "Parent:ApiKey" "12345"

Az előző parancs elérhetővé teszi a Parent:ApiKey konfigurációs kulcsot egy fejlesztő munkaállomásán az értékkel 12345.

A felhasználói titkos kódok létrehozásával, tárolásával és kezelésével kapcsolatos további információkért tekintse meg az alkalmazás titkos kulcsainak biztonságos tárolását a fejlesztés során ASP.NET Core-dokumentumban .

Környezeti változók

Az alkalmazáskonfigurációba betöltött értékek következő készlete a rendszer környezeti változói. A rendszer összes környezeti változóbeállítása mostantól elérhető a konfigurációs API-val. A hierarchikus értékek ellaposodnak és kettősponttal vannak elválasztva, amikor az alkalmazáson belül olvassák őket. Egyes operációs rendszerek azonban nem engedélyezik a kettőspont karakter környezetének változónevét. ASP.NET Core úgy oldja meg ezt a korlátozást, hogy a dupla aláhúzásjelekkel (__) rendelkező értékeket kettősponttá alakítja a hozzáférésükkor. A Parent:ApiKey fenti felhasználói titkos kódok szakasz értéke felülírható a környezeti változóval Parent__ApiKey.

Parancssori paraméterek

A konfiguráció parancssori argumentumként is megadható az alkalmazás indításakor. A két kötőjel (--) vagy a perjel (/) jelölésével jelezze a beállítani kívánt konfigurációs érték nevét és a konfigurálni kívánt értéket. A szintaxis a következő parancsokhoz hasonlít:

dotnet run CommandLineKey1=value1 --CommandLineKey2=value2 /CommandLineKey3=value3
dotnet run --CommandLineKey1 value1 /CommandLineKey2 value2
dotnet run Parent:ApiKey=67890

A web.config visszatérése

Ha az alkalmazást az IIS-en telepítette Windows rendszeren, a web.config fájl továbbra is konfigurálja az IIS-t az alkalmazás kezelésére. Az IIS alapértelmezés szerint hozzáad egy hivatkozást a ASP.NET Core Modulhoz (ANCM). Az ANCM egy natív IIS-modul, amely az alkalmazást a Kestrel webkiszolgáló helyett üzemelteti. Ez a web.config szakasz a következő XML jelöléshez hasonlít:

<?xml version="1.0" encoding="utf-8"?>
<configuration>
  <location path="." inheritInChildApplications="false">
    <system.webServer>
      <handlers>
        <add name="aspNetCore" path="*" verb="*" modules="AspNetCoreModuleV2" resourceType="Unspecified" />
      </handlers>
      <aspNetCore processPath=".\MyApp.exe"
                  stdoutLogEnabled="false"
                  stdoutLogFile=".\logs\stdout"
                  hostingModel="inprocess" />
    </system.webServer>
  </location>
</configuration>

Az alkalmazásspecifikus konfiguráció úgy határozható meg, hogy beágyaz egy environmentVariables elemet az aspNetCore elembe. Az ebben a szakaszban meghatározott értékek környezeti változókként jelennek meg a ASP.NET Core alkalmazásban. A környezeti változók megfelelően töltődnek be az alkalmazásindítás ezen szegmensében.

<aspNetCore processPath="dotnet"
      arguments=".\MyApp.dll"
      stdoutLogEnabled="false"
      stdoutLogFile=".\logs\stdout"
      hostingModel="inprocess">
  <environmentVariables>
    <environmentVariable name="ASPNETCORE_ENVIRONMENT" value="Development" />
    <environmentVariable name="Parent:ApiKey" value="67890" />
  </environmentVariables>
</aspNetCore>

Olvassa be a konfigurációt az alkalmazásban

ASP.NET Core alkalmazáskonfigurációt biztosít az IConfiguration interfészen keresztül. Ezt a konfigurációs felületet az Blazor összetevőknek, Blazor lapoknak és minden más ASP.NET Core által felügyelt osztálynak kell igényelnie, amelyhez hozzá kell férnie a konfigurációhoz. A ASP.NET Core-keretrendszer automatikusan feltölti ezt a felületet a korábban konfigurált feloldott konfigurációval. Egy Blazor oldalon vagy egy összetevő Razor-korrektúrája esetén az IConfiguration objektumot a @inject fájl tetején lévő direktívával szúrhatja be a következő módon:

@inject IConfiguration Configuration

Ez a fenti utasítás változóként IConfiguration teszi elérhetővé az Configuration objektumot a Razor-sablon többi részében.

Az egyes konfigurációs beállítások az indexelő paraméterként kért konfigurációs beállítási hierarchia megadásával olvashatók be:

var mySetting = Configuration["section1:key0"];

A teljes konfigurációs szakaszokat lekérheti azzal a GetSection módszerrel, hogy lekérjen egy kulcsgyűjteményt egy adott helyen az 1. szakasz konfigurációjának lekéréséhez hasonló GetSection("section1") szintaxissal a korábbi példából.

Erősen típusos konfiguráció

A Webes űrlapokkal lehetőség volt egy erősen típusos konfigurációtípus létrehozására, amely a ConfigurationSection típusból és a kapcsolódó típusokból örökölt. A ConfigurationSection lehetővé tette, hogy bizonyos üzleti szabályokat és feldolgozási folyamatokat konfiguráljunk ezekhez a konfigurációs értékekhez.

A ASP.NET Core-ban megadhat egy osztályhierarchiát, amely megkapja a konfigurációs értékeket. Ezek az osztályok:

• Nem kell szülőosztályt örökölnie.
• Olyan tulajdonságokat kell tartalmaznia public , amelyek megfelelnek a rögzíteni kívánt konfigurációs struktúra tulajdonságainak és típushivatkozásainak.

A korábbi appsettings.json mintához a következő osztályokat határozhatja meg az értékek rögzítéséhez:

public class MyConfig
{
    public MyConfigSection section0 { get; set;}

    public MyConfigSection section1 { get; set;}
}

public class MyConfigSection
{
    public string key0 { get; set; }

    public string key1 { get; set; }
}

Ez az osztályhierarchia úgy tölthető fel, hogy hozzáadja a következő sort a Startup.ConfigureServices metódushoz (vagy a megfelelő helyre a tulajdonságot használva a builder.Services helyett a services-ben).

services.Configure<MyConfig>(Configuration);

Az alkalmazás többi részében hozzáadhat egy bemeneti paramétert az osztályokhoz, vagy a @inject Razor-sablonokban IOptions<MyConfig> lévő irányelveket, hogy megkapják az erősen beírt konfigurációs beállításokat. A IOptions<MyConfig>.Value tulajdonság a MyConfig konfigurációs beállításokból kitöltött értéket adja meg.

@inject IOptions<MyConfig> options
@code {
    var MyConfiguration = options.Value;
    var theSetting = MyConfiguration.section1.key0;
}

A Beállítások funkcióval kapcsolatos további információk a ASP.NET Core-dokumentum Beállítások mintájában találhatók.

ElőzőKövetkező