Opublikuj w usługach IIS, ustawiając zmienną środowiskową

Czytając te dwa pytania / odpowiedzi, udało mi się uruchomić aplikację Asp.net 5 na serwerze IIS 8.5.

Asp.net vNext wczesna wersja beta publikuje w usługach IIS na serwerze Windows

Jak skonfigurować aplikację MVC6 do pracy z usługami IIS?

Problem polega na tym, że aplikacja internetowa nadal używa env.EnvironmentNamewartości, Developmentnawet gdy jest uruchomiona w usługach IIS.

Chcę też uruchomić dwie wersje tej samej sieci Web (etapowa, produkcyjna) na tym samym serwerze, więc potrzebuję metody ustawiania zmiennej osobno dla każdej sieci Web.

Jak to zrobić?

Ta odpowiedź została pierwotnie napisana dla ASP.NET Core RC1. W RC2 ASP.NET Core przeniesiono z ogólnego modułu obsługi httpPlafrom do specyficznego dla aspnetCore. Zwróć uwagę, że krok 3 zależy od używanej wersji ASP.NET Core.

Okazuje się, że zmienne środowiskowe dla projektów ASP.NET Core można ustawić bez konieczności ustawiania zmiennych środowiskowych dla użytkownika lub konieczności tworzenia wielu wpisów poleceń.

1. Przejdź do aplikacji w usługach IIS i wybierz Configuration Editor.
2. Wybierz Configuration Editor
3. Wybierz system.webServer/aspNetCore(RC2 i RTM) lub system.webServer/httpPlatform(RC1) w Sectioncombobox
4. Wybierz Applicationhost.config ...w Fromcombobox.
5. Kliknij prawym przyciskiem myszy enviromentVariableselement, wybierz 'environmentVariables' element, a następnie Edit Items.
6. Ustaw zmienne środowiskowe.
7. Zamknij okno i kliknij Zastosuj.
8. Gotowe

W ten sposób nie musisz tworzyć specjalnych użytkowników dla swojej puli ani tworzyć dodatkowych wpisów poleceń w project.json. Ponadto dodanie specjalnych poleceń dla każdego środowiska przerywa „buduj raz, wdrażaj wiele razy”, ponieważ będziesz musiał wywoływać dnu publishosobno dla każdego środowiska, zamiast raz publikować i wdrażać wynikowy artefakt wiele razy.

Zaktualizowano dla RC2 i RTM dzięki Markowi G i tredderowi.

Zaktualizuj plik web.config za pomocą sekcji <environmentVariables> w obszarze <aspNetCore>

<configuration>
  <system.webServer>
    <aspNetCore .....>
      <environmentVariables>
        <environmentVariable name="ASPNETCORE_ENVIRONMENT" value="Development" />
      </environmentVariables>
    </aspNetCore>
  </system.webServer>
</configuration>

Lub, aby uniknąć utraty tego ustawienia podczas nadpisywania pliku web.config, wprowadź podobne zmiany w pliku applicationHost.config, określając lokalizację witryny zgodnie z sugestią @NickAb.

<location path="staging.site.com">
    <system.webServer>
        <aspNetCore>
            <environmentVariables>
                <environmentVariable name="ASPNETCORE_ENVIRONMENT" value="Staging" />
            </environmentVariables>
        </aspNetCore>
    </system.webServer>
</location>
<location path="production.site.com">
    <system.webServer>
        <aspNetCore>
            <environmentVariables>
                <environmentVariable name="ASPNETCORE_ENVIRONMENT" value="Production" />
            </environmentVariables>
        </aspNetCore>
    </system.webServer>
</location>

Edycja: od wersji RC2 i RTM ta rada jest nieaktualna. Najlepszym sposobem, jaki znalazłem w tej wersji, jest edycja następujących sekcji web.config w usługach IIS dla każdego środowiska:

system.webServer/aspNetCore:

Edytuj wpis environmentVariable i dodaj ustawienie zmiennej środowiskowej:

ASPNETCORE_ENVIRONMENT : < Your environment name >

Jako alternatywę dla podejścia drpdrp możesz wykonać następujące czynności:

• W pliku project.json dodaj polecenia, które przekazują zmienną ASPNET_ENV bezpośrednio do Kestrel:

  "commands": {
      "Development": "Microsoft.AspNet.Server.Kestrel --ASPNET_ENV Development",
      "Staging": "Microsoft.AspNet.Server.Kestrel --ASPNET_ENV Staging",
      "Production": "Microsoft.AspNet.Server.Kestrel --ASPNET_ENV Production"
  }
  

• Podczas publikowania użyj --iis-commandopcji, aby określić środowisko:

  dnu publish --configuration Debug --iis-command Staging --out "outputdir" --runtime dnx-clr-win-x86-1.0.0-rc1-update1
  

Uważam, że to podejście jest mniej inwazyjne niż tworzenie dodatkowych użytkowników IIS.

Mam swoje aplikacje internetowe (PRODUKCJA, STAGING, TEST) hostowane na serwerze internetowym IIS. Nie można było więc polegać na zmiennej środowiskowej operatywnej systemu ASPNETCORE_ENVIRONMENT, ponieważ ustawienie jej na określoną wartość (na przykład STAGING) ma wpływ na inne aplikacje.

Aby obejść ten problem, zdefiniowałem niestandardowy plik (envsettings.json) w moim rozwiązaniu Visualstudio:

o następującej treści:

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

Następnie, w oparciu o typ mojej aplikacji (produkcja, staging lub test), ustawiam ten plik odpowiednio: zakładając, że wdrażam aplikację TEST, będę miał:

"ASPNETCORE_ENVIRONMENT": "Test"

Następnie w pliku Program.cs pobierz tę wartość, a następnie ustaw środowisko webHostBuildera:

    public class Program
    {
        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 enviromentValue = envSettings["ASPNETCORE_ENVIRONMENT"].ToString();

            var webHostBuilder = new WebHostBuilder()
                .UseKestrel()
                .CaptureStartupErrors(true)
                .UseSetting("detailedErrors", "true")
                .UseContentRoot(currentDirectoryPath)
                .UseIISIntegration()
                .UseStartup<Startup>();

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

            var host = webHostBuilder.Build();

            host.Run();
        }
    }

Pamiętaj, aby dołączyć plik envsettings.json do pliku PublishedOptions (project.json):

  "publishOptions":
  {
    "include":
    [
      "wwwroot",
      "Views",
      "Areas/**/Views",
      "envsettings.json",
      "appsettings.json",
      "appsettings*.json",
      "web.config"
    ]
  },

Dzięki temu rozwiązaniu mogę swobodnie korzystać z aplikacji ASP.NET CORE hostowanej w tych samych usługach IIS, niezależnie od wartości zmiennej środowiska.

Po obszernym googlowaniu znalazłem działające rozwiązanie, które składa się z dwóch kroków.

Pierwszym krokiem jest ustawienie zmiennej środowiskowej systemu ASPNET_ENV na produkcję i ponowne uruchomienie systemu Windows Server . Następnie wszystkie aplikacje internetowe otrzymują wartość „Produkcja” jako EnvironmentName.

Drugi krok (włączenie wartości „Staging” dla pomostowej strony internetowej) był raczej trudniejszy do wykonania prawidłowego działania, ale oto jest:

1. Utwórz nowego użytkownika systemu Windows, na przykład StagingPool na serwerze.
2. Dla tego użytkownika utwórz nową zmienną użytkownika ASPNETCORE_ENVIRONMENT o wartości „Staging” (możesz to zrobić, logując się jako ten użytkownik lub przez regedit)
3. Wróć jako administrator w menedżerze usług IIS i znajdź pulę aplikacji, w której działa sieć Web Staging, iw Ustawieniach zaawansowanych ustaw Tożsamość na pulę StagingPool użytkownika .
4. Ustaw także opcję Załaduj profil użytkownika na wartość true , aby załadować zmienne środowiskowe. <- bardzo ważne!
5. Upewnij się, że StagingPool ma prawa dostępu do folderu WWW oraz Zatrzymaj i uruchom pulę aplikacji.

Teraz w sieci Web Staging powinna mieć wartość EnvironmentName ustawioną na „Staging”.

Aktualizacja: W systemie Windows 7+ jest polecenie, które może ustawić zmienne środowiskowe z wiersza poleceń CMD również dla określonego użytkownika. To wyświetla pomoc oraz próbki:

>setx /?

Alternatywnie można przekazać żądane ASPNETCORE_ENVIRONMENTdo polecenia dotnet Publishing jako argument przy użyciu:

/p:EnvironmentName=Staging

na przykład:

dotnet publish /p:Configuration=Release /p:EnvironmentName=Staging

Spowoduje to wygenerowanie pliku web.config z odpowiednim środowiskiem określonym dla Twojego projektu:

<environmentVariables>
  <environmentVariable name="ASPNETCORE_ENVIRONMENT" value="Staging" />
</environmentVariables>

Oprócz opcji wymienionych powyżej istnieje kilka innych rozwiązań, które dobrze sprawdzają się w przypadku wdrożeń automatycznych lub wymagają mniejszej liczby zmian w konfiguracji.

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 Developmentdla 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 używają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

Aby rozszerzyć odpowiedź @ tredder, możesz zmienić zmienne environmentVariables za pomocą appcmd

Inscenizacja

%windir%\system32\inetsrv\appcmd set config "staging.example.com" /section:system.webServer/aspNetCore /+environmentVariables.[name='ASPNETCORE_ENVIRONMENT',value='Staging'] /commit:APPHOST

Produkcja

%windir%\system32\inetsrv\appcmd set config "example.com" /section:system.webServer/aspNetCore /+environmentVariables.[name='ASPNETCORE_ENVIRONMENT',value='Production'] /commit:APPHOST

Podobnie jak w przypadku innych odpowiedzi, chciałem upewnić się, że moje ustawienie środowiska ASP.NET Core 2,1 będzie zachowywane we wszystkich wdrożeniach, ale również będzie stosowane tylko do określonej witryny.

Zgodnie z dokumentacją Microsoftu można ustawić zmienną środowiskową w puli aplikacji za pomocą następującego polecenia PowerShell w IIS 10:

$appPoolName = "AppPool"
$envName = "Development"
cd "$env:SystemRoot\system32\inetsrv"
.\appcmd.exe set config -section:system.applicationHost/applicationPools /+"[name='$appPoolName'].environmentVariables.[name='ASPNETCORE_ENVIRONMENT',value='$envName']" /commit:apphost

Niestety nadal muszę korzystać z usług IIS 8.5 i pomyślałem, że nie miałem szczęścia. Jednak nadal można uruchomić prosty skrypt programu PowerShell, aby ustawić wartość zmiennej środowiskowej specyficznej dla witryny dla ASPNETCORE_ENVIRONMENT:

Import-Module -Name WebAdministration
$siteName = "Site"
$envName = "Development"
Set-WebConfigurationProperty -PSPath IIS:\ -Location $siteName -Filter /system.webServer/aspNetCore/environmentVariables -Name . -Value @{ Name = 'ASPNETCORE_ENVIRONMENT'; Value = $envName }

Co musisz wiedzieć w jednym miejscu:

• Aby zmienne środowiskowe przesłaniały wszelkie ustawienia konfiguracji, muszą być poprzedzone przedrostkiem ASPNETCORE_.
• Jeśli chcesz dopasować węzły podrzędne w konfiguracji JSON, użyj :jako separatora. Jeśli platforma nie zezwala na dwukropki w kluczach zmiennych środowiskowych, użyj __zamiast tego.
• Chcesz, aby Twoje ustawienia znalazły się w ApplicationHost.config. Użycie edytora konfiguracji usług IIS spowoduje, że dane wejściowe zostaną zapisane w aplikacji Web.config- i zostaną nadpisane przy następnym wdrożeniu!

• W przypadku modyfikowania ApplicationHost.configchcesz użyć, appcmd.exeaby upewnić się, że modyfikacje są spójne. Przykład:%systemroot%\system32\inetsrv\appcmd.exe set config "Default Web Site/MyVirtualDir" -section:system.webServer/aspNetCore /+"environmentVariables.[name='ASPNETCORE_AWS:Region',value='eu-central-1']" /commit:site

• Znaki, które nie są bezpieczne dla adresu URL, mogą zostać zmienione jako Unicode, jak w %u007bprzypadku lewego nawiasu klamrowego.

• Aby wyświetlić aktualne ustawienia (w połączeniu z wartościami z Web.config): %systemroot%\system32\inetsrv\appcmd.exe list config "Default Web Site/MyVirtualDir" -section:system.webServer/aspNetCore
• Jeśli uruchomisz polecenie, aby ustawić klucz konfiguracyjny wiele razy dla tego samego klucza, zostanie on dodany wiele razy! Aby usunąć istniejącą wartość, użyj czegoś takiego jak %systemroot%\system32\inetsrv\appcmd.exe set config "Default Web Site/MyVirtualDir" -section:system.webServer/aspNetCore /-"environmentVariables.[name='ASPNETCORE_MyKey',value='value-to-be-removed']" /commit:site.

Rozwiązanie @tredder z możliwością edycji applicationHost.config to takie, które działa, jeśli masz kilka różnych aplikacji znajdujących się w katalogach wirtualnych w usługach IIS.

Mój przypadek to:

• Mam projekt API i projekt APP , w tej samej domenie, umieszczone w różnych katalogach wirtualnych
• Wydaje się, że strona główna XXX nie propaguje zmiennej ASPNETCORE_ENVIRONMENT do swoich elementów podrzędnych w katalogach wirtualnych i ...
• ... Nie mogę ustawić zmiennych w katalogu wirtualnym zgodnie z opisem @NickAb (otrzymano błąd Żądanie nie jest obsługiwane. (Wyjątek od HRESULT: 0x80070032) podczas zapisywania zmian w edytorze konfiguracji):

• Przechodzenie do applicationHost.config i ręczne tworzenie węzłów w ten sposób:

  <location path="XXX/app"> <system.webServer> <aspNetCore> <environmentVariables> <clear /> <environmentVariable name="ASPNETCORE_ENVIRONMENT" value="Staging" /> </environmentVariables> </aspNetCore> </system.webServer> </location> <location path="XXX/api"> <system.webServer> <aspNetCore> <environmentVariables> <clear /> <environmentVariable name="ASPNETCORE_ENVIRONMENT" value="Staging" /> </environmentVariables> </aspNetCore> </system.webServer> </location>

i ponowne uruchomienie usług IIS wykonało zadanie.

Wiem, że udzielono wielu odpowiedzi, ale w moim przypadku dodałem wersje web. {Environment} .config w moim projekcie i podczas publikowania dla określonego środowiska wartość jest zastępowana.

Na przykład dla Staging (web.Staging.config)

<?xml version="1.0"?>
<configuration xmlns:xdt="http://schemas.microsoft.com/XML-Document-Transform">
    <location>
        <system.webServer>
            <aspNetCore>
                <environmentVariables xdt:Transform="InsertIfMissing">
                    <environmentVariable name="ASPNETCORE_ENVIRONMENT"
                                         value="Staging"
                                         xdt:Locator="Match(name)"
                                         xdt:Transform="InsertIfMissing" />
                </environmentVariables>
            </aspNetCore>
        </system.webServer>
    </location>
</configuration>

W przypadku wydania lub produkcji zrobię to (web.Release.config)

<?xml version="1.0"?>
<configuration xmlns:xdt="http://schemas.microsoft.com/XML-Document-Transform">
    <location>
        <system.webServer>
            <aspNetCore>
                <environmentVariables xdt:Transform="InsertIfMissing">
                    <environmentVariable name="ASPNETCORE_ENVIRONMENT"
                                         value="Release"
                                         xdt:Locator="Match(name)"
                                         xdt:Transform="InsertIfMissing" />
                </environmentVariables>
            </aspNetCore>
        </system.webServer>
    </location>
</configuration>

Następnie podczas publikacji wybiorę lub ustawię nazwę środowiska. I to zastąpi wartość środowiska w ostatecznym pliku web.config.

Aby uzyskać szczegółowe informacje o błędzie, musiałem dodać ASPNETCORE_ENVIRONMENTzmienną środowiskową dla odpowiedniej puli aplikacji system.applicationHost/applicationPools .

Uwaga: aplikacja internetowa w moim przypadku była ASP.NET Core 2hostowana na serwerze IIS 10. Można to zrobić przez Configuration Editorin IIS Manager(zobacz Edycja kolekcji za pomocą Edytora konfiguracji, aby dowiedzieć się, gdzie znaleźć ten edytor IIS Manager).

Utworzyłem repozytorium do publikowania IIS z konfiguracją środowiska w Web.config.

https://github.com/expressiveco/AspnetCoreWebConfigForEnvironment

• Ustawiać
  • Pobierz sekcje z plików .csproj i .user.csproj do plików projektu.
  • Pobierz pliki MyAspNetEnvironment.props, web.development.config i web.production.config.
• Konfiguracja
  • Zmień odpowiednio wartość właściwości ASPNETCORE_ENVIRONMENT w user.csproj.

Zmodyfikowałem odpowiedź, którą otrzymał @Christian Del Bianco . Zmieniłem proces dla .net core 2 i upper jako plik project.json teraz absolutny.

1. Najpierw utwórz plik appsettings.json w katalogu głównym. z zawartością

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

2. Następnie utwórz dwa kolejne pliki ustawień appsettings.Development.json i appsettings.Production.json z wymaganą konfiguracją.

3. Dodaj niezbędny kod, aby skonfigurować środowisko do pliku Program.cs .

   public class Program
   {
   public static void Main(string[] args)
   {
       var logger = NLogBuilder.ConfigureNLog("nlog.config").GetCurrentClassLogger();
   
     ***var currentDirectoryPath = Directory.GetCurrentDirectory();
       var envSettingsPath = Path.Combine(currentDirectoryPath, "envsettings.json");
       var envSettings = JObject.Parse(File.ReadAllText(envSettingsPath));
       var enviromentValue = envSettings["ASPNETCORE_ENVIRONMENT"].ToString();***
   
       try
       {
           ***CreateWebHostBuilder(args, enviromentValue).Build().Run();***
       }
       catch (Exception ex)
       {
           //NLog: catch setup errors
           logger.Error(ex, "Stopped program because of setup related exception");
           throw;
       }
       finally
       {
           NLog.LogManager.Shutdown();
       }
   }
   
   public static IWebHostBuilder CreateWebHostBuilder(string[] args, string enviromentValue) =>
       WebHost.CreateDefaultBuilder(args)
           .UseStartup<Startup>()
           .ConfigureLogging(logging =>
           {
               logging.ClearProviders();
               logging.SetMinimumLevel(Microsoft.Extensions.Logging.LogLevel.Trace);
           })
           .UseNLog()
           ***.UseEnvironment(enviromentValue);***
   

   }

4. Dodaj envsettings.json do .csproj pliku dla kopii opublikowanym katalogu.

      <ItemGroup>
           <None Include="envsettings.json" CopyToPublishDirectory="Always" />
       </ItemGroup>
   

5. Teraz po prostu zmień ASPNETCORE_ENVIRONMENT, jak chcesz w pliku envsettings.json i opublikuj.

Dla tych, którzy szukają tego w Azure Devops pipeline, można to osiągnąć, dodając zadanie PowerShell na maszynach docelowych i uruchamiając następujący skrypt:

$envVariables = (
  @{name='VARIABLE1';value='Value1'},
  @{name='VARIABLE2';value='Value2'}
)

Set-WebConfigurationProperty -PSPath IIS:\ -Location $('mySite') -Filter /system.webServer/aspNetCore/environmentVariables -Name . -Value $envVariables