jak ustawić ASPNETCORE_ENVIRONMENT, aby był brany pod uwagę przy publikowaniu podstawowej aplikacji asp.net?

Kiedy publikuję moją aplikację internetową asp.net core w moim lokalnym systemie plików, zawsze pobiera ona zmienną production-config i ASPNETCORE_ENVIRONMENT z wartością = "Production".

jak i gdzie mam ustawić wartość zmiennej ASPNETCORE_ENVIRONMENT, aby była uwzględniana nie tylko do debugowania, ale także do publikacji ? Próbowałem już bez powodzenia następujących opcji:

• w ustawieniach systemu Windows
• w pliku .pubxml
• w launchSettings.json
• w project.json

Poza opcjami wymienionymi powyżej istnieje kilka innych rozwiązań.

1. Modyfikacja pliku projektu (.CsProj)

MSBuild obsługuje EnvironmentNameWłaściwość, która może pomóc ustawić odpowiednią zmienną środowiskową zgodnie ze środowiskiem, które chcesz wdrożyć. Nazwa środowiska zostanie dodana w pliku web.config podczas fazy publikowania.

Po prostu otwórz plik projektu (* .csProj) i dodaj następujący kod XML.

<!-- 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>

Powyższy kod dodałby nazwę środowiska, taką jak w Developmentprzypadku konfiguracji debugowania lub jeśli nie określono żadnej konfiguracji. W przypadku każdej innej konfiguracji nazwa środowiska będzie znajdować się Productionw wygenerowanym pliku web.config. Więcej szczegółów tutaj

2. Dodanie właściwości EnvironmentName w profilach publikowania.

<EnvironmentName>Właściwość możemy również dodać w profilu publikacji. Otwórz plik profilu publikowania, który znajduje się w Properties/PublishProfiles/{profilename.pubxml}Spowoduje to ustawienie nazwy środowiska w pliku web.config po opublikowaniu projektu. Więcej szczegółów tutaj

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

3. Opcje wiersza polecenia wykorzystujące dotnet Publishing

Dodatkowo możemy przekazać tę właściwość EnvironmentNamejako opcję wiersza poleceń do dotnet publishpolecenia. Następujące polecenie zawierałoby zmienną środowiskową, taką jak Developmentw pliku web.config.

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

Opcja 1:

Aby ustawić zmienną środowiskową ASPNETCORE_ENVIRONMENT w systemie Windows,

Wiersz poleceń - setx ASPNETCORE_ENVIRONMENT "Development"

PowerShell - $Env:ASPNETCORE_ENVIRONMENT = "Development"

W przypadku innych systemów operacyjnych zapoznaj się z tym - https://docs.microsoft.com/en-us/aspnet/core/fundamentals/environments

Opcja 2:

Jeśli chcesz ustawić ASPNETCORE_ENVIRONMENT stosując web.confignastępnie dodać aspNetCorejak to-

<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>

Prosty sposób na ustawienie go w Visual Studio IDE.

Projekt> Właściwości> Debuguj> Zmienne środowiskowe

Należy postępować zgodnie z instrukcjami zawartymi w dokumentacji , używając rozszerzenia 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>

Zauważ, że możesz również ustawić inne zmienne środowiskowe.

Moduł ASP.NET Core umożliwia określenie zmiennych środowiskowych dla procesu określonego w atrybucie processPath przez określenie ich w co najmniej jednym elemencie podrzędnym environmentVariable elementu kolekcji environmentVariables w elemencie aspNetCore. Zmienne środowiskowe ustawione w tej sekcji mają pierwszeństwo przed zmiennymi środowiskowymi systemu dla procesu.

Oto jak możemy ustawić w czasie wykonywania:

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();
}

1. Utwórz pliki appSettings. *. JSON. (Przykłady: appsettings.Development.json, appsettings.Staging.json, appsettings.Production.json)

2. Dodaj swoje zmienne do tych plików.

3. Utwórz osobny profil publikowania dla każdego środowiska, tak jak zwykle.

4. Otwórz PublishProfiles / Development.pubxml (nazewnictwo będzie oparte na tym, co nadałeś nazwie profilowi ​​publikacji).

5. Po prostu dodaj tag do PublishProfile, aby ustawić zmienną EnvironmentName , a konwencja nazewnictwa plików appSettings. *. Json zrobi resztę.

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

Źródła: https://docs.microsoft.com/en-us/aspnet/core/host-and-deploy/visual-studio-publish-profiles?view=aspnetcore-3.1

Zobacz sekcję „Ustawianie środowiska”.

W najnowszej wersji dotnet cli (2.1.400 lub nowszej) możesz po prostu ustawić tę właściwość msbuild, $(EnvironmentName)a narzędzie publikowania zajmie się dodaniem ASPNETCORE_ENVIRONMENT do pliku web.config z nazwą środowiska.

Ponadto obsługa XDT jest dostępna od wersji 2.2.100-preview1.

Próbka: https://github.com/vijayrkn/webconfigtransform/blob/master/README.md

Tę zmienną można zapisać w formacie json. Na przykład envsettings.json z zawartością jak poniżej

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

   "ASPNETCORE_ENVIRONMENT": "Development"
  }

Później zmodyfikuj swój program.cs jak poniżej

  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();
     }
 }

W ten sposób zawsze będzie uwzględniony w publikacji i możesz zmienić wymaganą wartość w zależności od środowiska, w którym jest hostowana strona internetowa. Ta metoda może być również używana w aplikacji konsoli, ponieważ zmiany są w Program.cs

Wiem, że to stary post, ale pomyślałem, że wrzucę moje proste rozwiązanie do miksu, ponieważ nikt tego nie zasugerował.

Używam bieżącego katalogu, aby określić bieżące środowisko, a następnie odwracam parametry połączenia i zmienną środowiskową. Działa to świetnie, o ile masz konwencję nazewnictwa folderów witryny, taką jak test / beta / sandbox.

    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();
    }

Okazało się, że działa dla mnie, ustawiając tę ​​zmienną bezpośrednio na platformie Azure (jeśli jej używasz). Po prostu wybierz swoją aplikację internetową -> konfiguracja -> ustawienia aplikacji i dodaj zmienną oraz jej wartość, a następnie naciśnij przycisk Zapisz.

Inną opcją, której używamy w naszych projektach, aby móc ustawić środowisko na witrynę, jest dodanie do projektu pliku Parameters.xml o następującej treści:

<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>

Akcją kompilacji dla tego pliku jest Zawartość, a Akcją kopiowania jest Kopiuj, jeśli nowsza, więc będzie on częścią pakietu do wdrożenia.

Następnie, aby wdrożyć pakiet i ustawić środowisko, w Release, w ramach zadania „WinRM - IIS Web App Deployment” (działa równie dobrze, gdy korzystamy z zadania „IIS web app deploy”), ustawiamy dodatkowe argumenty dla msdeploy :

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

W ten sposób możemy mieć wiele wersji, wszystkie wykorzystujące ten sam artefakt, ale wdrożone w różnych środowiskach.