Wie stelle ich ASPNETCORE_ENVIRONMENT so ein, dass es für die Veröffentlichung einer asp.net-Kernanwendung berücksichtigt wird?

Wenn ich meine asp.net-Kernwebanwendung in meinem lokalen Dateisystem veröffentliche, werden immer die Produktionskonfiguration und die Variable ASPNETCORE_ENVIRONMENT mit dem Wert = "Produktion" verwendet.

Wie und wo muss ich den Wert der Variablen ASPNETCORE_ENVIRONMENT festlegen, damit er nicht nur für das Debuggen, sondern auch für die Veröffentlichung berücksichtigt wird ? Ich habe bereits die folgenden Optionen ohne Erfolg ausprobiert:

• in Windows-Einstellungen
• in der .pubxml-Datei
• in launchSettings.json
• in project.json

Neben den oben genannten Optionen gibt es noch einige andere Lösungen.

1. Ändern der Projektdatei (.CsProj)

MSBuild unterstützt die EnvironmentNameEigenschaft, mit deren Hilfe Sie die richtige Umgebungsvariable für die Umgebung festlegen können, die Sie bereitstellen möchten. Der Umgebungsname wird während der Veröffentlichungsphase in der Datei web.config hinzugefügt.

Öffnen Sie einfach die Projektdatei (* .csProj) und fügen Sie das folgende XML hinzu.

<!-- Custom Property Group added to add the Environment name during publish
  The EnvironmentName property is used during the publish for the Environment variable in web.config
  -->
  <PropertyGroup Condition=" '$(Configuration)' == '' Or '$(Configuration)' == 'Debug'">
    <EnvironmentName>Development</EnvironmentName>
  </PropertyGroup>
  <PropertyGroup Condition=" '$(Configuration)' != '' AND '$(Configuration)' != 'Debug' ">
    <EnvironmentName>Production</EnvironmentName>
  </PropertyGroup>

Der obige Code fügt den Umgebungsnamen wie Developmentbei der Debug-Konfiguration hinzu oder wenn keine Konfiguration angegeben ist. Bei jeder anderen Konfiguration befindet sich der Umgebungsname Productionin der generierten Datei web.config. Weitere Details hier

2. Hinzufügen der EnvironmentName-Eigenschaft in den Veröffentlichungsprofilen.

Wir können die <EnvironmentName>Eigenschaft auch im Veröffentlichungsprofil hinzufügen . Öffnen Sie die Veröffentlichungsprofildatei unter Properties/PublishProfiles/{profilename.pubxml}Dies wird der Umgebungsname in web.config festgelegt, wenn das Projekt veröffentlicht wird. Weitere Details hier

<PropertyGroup>
  <EnvironmentName>Development</EnvironmentName>
</PropertyGroup>

3. Befehlszeilenoptionen mit Dotnet Publish

Zusätzlich können wir die Eigenschaft EnvironmentNameals Befehlszeilenoption an den dotnet publishBefehl übergeben. Der folgende Befehl würde die Umgebungsvariable wie Developmentin der Datei web.config enthalten.

dotnet publish -c Debug -r win-x64 /p:EnvironmentName=Development

Option 1:

So legen Sie die Umgebungsvariable ASPNETCORE_ENVIRONMENT in Windows fest:

Befehlszeile - setx ASPNETCORE_ENVIRONMENT "Development"

Power Shell - $Env:ASPNETCORE_ENVIRONMENT = "Development"

Weitere Betriebssysteme finden Sie unter https://docs.microsoft.com/en-us/aspnet/core/fundamentals/environments

Option 2:

Wenn Sie ASPNETCORE_ENVIRONMENT mit festlegen möchten, web.configfügen Sie aspNetCoreFolgendes hinzu:

<configuration>
  <!--
    Configure your application settings in appsettings.json. Learn more at http://go.microsoft.com/fwlink/?LinkId=786380
  -->
  <system.webServer>
    <handlers>
      <add name="aspNetCore" path="*" verb="*" modules="AspNetCoreModule" resourceType="Unspecified" />
    </handlers>
    <aspNetCore processPath=".\MyApplication.exe" arguments="" stdoutLogEnabled="false" stdoutLogFile=".\logs\stdout" forwardWindowsAuthToken="false">
      <environmentVariables>
        <environmentVariable name="ASPNETCORE_ENVIRONMENT" value="Development" />
      </environmentVariables>
    </aspNetCore>
  </system.webServer>
</configuration>

Einfache Möglichkeit, es in der Visual Studio IDE einzustellen.

Projekt> Eigenschaften> Debug> Umgebungsvariablen

Befolgen Sie die Anweisungen in der Dokumentation unter Verwendung der web.config.

<aspNetCore processPath="dotnet"
        arguments=".\MyApp.dll"
        stdoutLogEnabled="false"
        stdoutLogFile="\\?\%home%\LogFiles\aspnetcore-stdout">
  <environmentVariables>
    <environmentVariable name="ASPNETCORE_ENVIRONMENT" value="Production" />
    <environmentVariable name="CONFIG_DIR" value="f:\application_config" />
  </environmentVariables>
</aspNetCore>

Beachten Sie, dass Sie auch andere Umgebungsvariablen festlegen können.

Mit dem ASP.NET-Kernmodul können Sie Umgebungsvariablen für den im Attribut processPath angegebenen Prozess angeben, indem Sie sie in einem oder mehreren untergeordneten Elementen der Datei environmentVariable eines Auflistungselements environmentVariables unter dem Element aspNetCore angeben. In diesem Abschnitt festgelegte Umgebungsvariablen haben Vorrang vor Systemumgebungsvariablen für den Prozess.

So können wir zur Laufzeit einstellen:

public class Program
{
    public static void Main(string[] args)
    {
        Environment.SetEnvironmentVariable("ASPNETCORE_ENVIRONMENT", "Development");

        BuildWebHost(args).Run();
    }

    public static IWebHost BuildWebHost(string[] args) =>
        WebHost.CreateDefaultBuilder(args)
            .UseStartup<Startup>()
            .Build();
}

Mit der neuesten Version von dotnet cli (2.1.400 oder höher) können Sie einfach diese msbuild-Eigenschaft festlegen $(EnvironmentName)und das Veröffentlichungswerkzeug sorgt dafür, dass der web.config ASPNETCORE_ENVIRONMENT mit dem Umgebungsnamen hinzugefügt wird.

XDT-Unterstützung ist ab 2.2.100-Vorschau1 verfügbar.

Beispiel: https://github.com/vijayrkn/webconfigtransform/blob/master/README.md

1. Erstellen Sie Ihre Appsettings. *. JSON-Dateien. (Beispiele: appsettings.Development.json, appsettings.Staging.json, appsettings.Production.json)

2. Fügen Sie diesen Dateien Ihre Variablen hinzu.

3. Erstellen Sie für jede Umgebung ein separates Veröffentlichungsprofil, wie Sie es normalerweise tun würden.

4. Öffnen Sie PublishProfiles / Development.pubxml (die Benennung basiert auf dem, was Sie als Veröffentlichungsprofil bezeichnet haben).

5. Fügen Sie dem PublishProfile einfach ein Tag hinzu , um die Variable EnvironmentName festzulegen, die Namenskonvention für Appsettings. *. Json-Dateien erledigt den Rest.

    <PropertyGroup>
      <EnvironmentName>Development</EnvironmentName>
    </PropertyGroup>

Referenz: https://docs.microsoft.com/en-us/aspnet/core/host-and-deploy/visual-studio-publish-profiles?view=aspnetcore-3.1

Weitere Informationen finden Sie im Abschnitt „Einstellen der Umgebung“.

Diese Variable kann in json gespeichert werden. Zum Beispiel envsettings.json mit dem folgenden Inhalt

  {
   // Possible string values reported below. When empty it use ENV variable value or 
     // Visual Studio setting.
     // - Production
     // - Staging
     // - Test
     // - Development

   "ASPNETCORE_ENVIRONMENT": "Development"
  }

Ändern Sie später Ihre program.cs wie folgt

  public class Program
  {
    public static IConfiguration Configuration { get; set; }
    public static void Main(string[] args)
    {
        var currentDirectoryPath = Directory.GetCurrentDirectory();
        var envSettingsPath = Path.Combine(currentDirectoryPath, "envsettings.json");
        var envSettings = JObject.Parse(File.ReadAllText(envSettingsPath));
        var environmentValue = envSettings["ASPNETCORE_ENVIRONMENT"].ToString();

        var builder = new ConfigurationBuilder()
               .SetBasePath(Directory.GetCurrentDirectory())
               .AddJsonFile("appsettings.json");

        Configuration = builder.Build();
          var webHostBuilder = new WebHostBuilder()
            .UseKestrel()
            .CaptureStartupErrors(true)
            .UseContentRoot(currentDirectoryPath)
            .UseIISIntegration()
            .UseStartup<Startup>();

        // If none is set it use Operative System hosting enviroment
        if (!string.IsNullOrWhiteSpace(environmentValue))
        {
            webHostBuilder.UseEnvironment(environmentValue);
        }

        var host = webHostBuilder.Build();

        host.Run();
     }
 }

Auf diese Weise wird es immer in die Veröffentlichung einbezogen, und Sie können je nach Umgebung, in der die Website gehostet wird, den erforderlichen Wert ändern. Diese Methode kann auch in der Konsolen-App verwendet werden, da sich die Änderungen in Program.cs befinden

Ich habe festgestellt, dass es für mich funktioniert, indem ich diese Variable direkt auf Azure platorm festgelegt habe (falls Sie sie verwenden). Wählen Sie einfach Ihre Webanwendung -> Konfiguration -> Anwendungseinstellungen aus, fügen Sie die Variable und ihren Wert hinzu und klicken Sie dann auf die Schaltfläche Speichern.

Eine andere Option, die wir in unseren Projekten verwenden, um die Umgebung pro Site festlegen zu können, besteht darin, dem Projekt eine Parameters.xml-Datei mit folgendem Inhalt hinzuzufügen:

<parameters>
      <parameter name="IIS Web Application Name" defaultValue="MyApp" tags="IisApp" />    
      <parameter name="Environment" description="Environment" tags="">
        <parameterEntry kind="XmlFile" scope="Web.config"  match="/configuration/location/system.webServer/aspNetCore/environmentVariables/environmentVariable[@name='ASPNETCORE_ENVIRONMENT']/@value" />
      </parameter>    
</parameters>

Die Erstellungsaktion für diese Datei lautet " Inhalt" und die Kopieraktion lautet " Kopieren, wenn sie neuer ist", sodass sie Teil des zu implementierenden Pakets ist.

Um das Paket bereitzustellen und die Umgebung in der Version unter der Aufgabe "WinRM - IIS-Webanwendungsbereitstellung" festzulegen (dies funktioniert genauso gut, wenn die Aufgabe "IIS-Webanwendungsbereitstellung" verwendet wird), legen wir zusätzliche Argumente für msdeploy fest ::

-setParam:kind=ProviderPath,scope=contentPath,value="MySite" -setParam:name="Environment",value="Stage"

Auf diese Weise können wir mehrere Releases haben, die alle dasselbe Artefakt verwenden, aber als unterschiedliche Umgebungen bereitgestellt werden.

Ich weiß, dass dies ein alter Beitrag ist, dachte jedoch, ich würde meine einfache Lösung in die Mischung einfließen lassen, da niemand dies vorgeschlagen hat.

Ich benutze das aktuelle Verzeichnis, um die aktuelle Umgebung zu bestimmen, und drehe dann die Verbindungszeichenfolge und die Umgebungsvariable um. Dies funktioniert hervorragend, solange Sie eine Namenskonvention für Ihre Site-Ordner wie test / beta / sandbox haben.

    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        var dir = Environment.CurrentDirectory;
        string connectionString;

        if (dir.Contains("test", StringComparison.OrdinalIgnoreCase))
        {
            connectionString = new ConnectionStringBuilder(server: "xxx", database: "xxx").ConnectionString;
            Environment.SetEnvironmentVariable("ASPNETCORE_ENVIRONMENT", "Development");
        }
        else
        {
            connectionString = new ConnectionStringBuilder(server: "xxx", database: "xxx").ConnectionString;
            Environment.SetEnvironmentVariable("ASPNETCORE_ENVIRONMENT", "Production");
        }

        optionsBuilder.UseSqlServer(connectionString);
        optionsBuilder.UseLazyLoadingProxies();
        optionsBuilder.EnableSensitiveDataLogging();
    }