Automatycznie ustawić plik appsettings.json dla środowisk deweloperskich i wydań w asp.net core?

105

Zdefiniowałem w moich wartościach appsettings.jsontakie rzeczy, jak parametry połączenia z bazą danych, lokalizacje webapi i tym podobne, które są różne dla środowisk programistycznych, tymczasowych i na żywo.

Czy istnieje sposób, aby mieć wiele appsettings.jsonplików (np. appsettings.live.jsonItp.) I mieć aplikację asp.net po prostu „wiedzieć”, którego użyć na podstawie uruchomionej konfiguracji kompilacji?

meds
źródło

Odpowiedzi:

31

Możesz użyć kompilacji warunkowej:

public Startup(IHostingEnvironment env)
{
    var builder = new ConfigurationBuilder()
    .SetBasePath(env.ContentRootPath)
    .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
#if SOME_BUILD_FLAG_A
    .AddJsonFile($"appsettings.flag_a.json", optional: true)
#else
    .AddJsonFile($"appsettings.no_flag_a.json", optional: true)
#endif
    .AddEnvironmentVariables();
    this.configuration = builder.Build();
}
Dmitry
źródło
28
Należy ustawić zmienną środowiskową w kompilacji MSBuild / TFS. Kompilacja warunkowa prowadzi do błędów w przypadku czegoś, co można łatwo obsłużyć w kompilacjach CI. To znaczy .AddJsonFile ($ "appsettings. {Env.EnvironmentName} .json", opcjonalnie: true)
Nick Turner
1
Zobacz moją odpowiedź ( stackoverflow.com/a/50331886/1319086 ) dla zmiennej środowiskowej
Jonatan Dragon
10
Takie podejście wymusza rekompilację kodu specjalnie dla każdego środowiska, co uniemożliwia jego redystrybucję / instalację w innym miejscu.
tvdias
2
Pytanie dotyczyło „znajomości konfiguracji kompilacji”
Dmitry
6
Nie należy tego oznaczać jako zaakceptowanej odpowiedzi - choć jest to rozwiązanie, nie jest najlepszą praktyką.
Charleh
98

Dodałem zrzuty ekranu ze środowiska pracy, ponieważ kosztowało mnie to kilka godzin badań i rozwoju.

  1. Najpierw dodaj klucz do swojego launch.jsonpliku.

    Zobacz poniższy zrzut ekranu, dodałem Developmentjako moje środowisko.

    Deklaracja zmiennej środowiskowej w launch.json

  2. Następnie w swoim projekcie utwórz nowy appsettings.{environment}.jsonplik zawierający nazwę środowiska.

    Na poniższym zrzucie ekranu poszukaj dwóch różnych plików o nazwach:

    • appsettings.Development.Json
    • appSetting.json


    Widok projektu plików JSON appSettings

  3. Na koniec skonfiguruj go do swojej StartUpklasy w następujący sposób:

    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)
            .AddEnvironmentVariables();
    
        Configuration = builder.Build();
    }
    
  4. I w końcu możesz uruchomić go z wiersza poleceń w następujący sposób:

    dotnet run --environment "Development"
    

    gdzie "Development"jest nazwa mojego środowiska.

Bharat
źródło
2
Wypróbowałem to i działa świetnie. VS2017 wyświetla nawet różne wersje, tak jak w pliku podstawowym. głos w górę.
Roberto
1
jak to zrobić w rdzeniu 2.2, ponieważ ihostingenvironment został usunięty
djack109
2
@ djack109 powinieneś użyć IWebHostEnvironmentzamiast tego.
alessandrocb
71

Aktualizacja dla .NET Core 3.0+

  1. Możesz użyć, CreateDefaultBuilderktóry automatycznie zbuduje i przekaże obiekt konfiguracyjny do Twojej klasy startowej:

    WebHost.CreateDefaultBuilder(args).UseStartup<Startup>();
    
    public class Startup
    {
        public Startup(IConfiguration configuration) // automatically injected
        {
            Configuration = configuration;
        }
        public IConfiguration Configuration { get; }
        /* ... */
    }
    
  2. CreateDefaultBuilderautomatycznie dołącza odpowiedni plik, więc dodaj oddzielny plik appsettings dla każdego środowiska:appsettings.Environment.json

    appsettings.env.json

  3. Następnie ustaw ASPNETCORE_ENVIRONMENT zmienną środowiskową podczas uruchamiania / debugowania

Jak ustawić zmienne środowiskowe

W zależności od IDE istnieje kilka miejsc, w których projekty dotnet tradycyjnie szukają zmiennych środowiskowych:

  • W przypadku programu Visual Studio przejdź do projektu> właściwości> debugowania> zmienne środowiskowe:

    Visual Studio - zmienne środowiskowe

  • W przypadku programu Visual Studio Code edytuj .vscode/launch.json> env:

    Visual Studio Code> Uruchom środowisko

  • Korzystając z Ustawień uruchamiania , edytuj Properties/launchSettings.json> environmentVariables:

    Uruchom Ustawienia

    Które można również wybrać z paska narzędzi w programie Visual Studio

    Uruchom menu rozwijane ustawień

  • Korzystając z interfejsu wiersza polecenia dotnet , użyj odpowiedniej składni do ustawiania zmiennych środowiskowych dla systemu operacyjnego

    Uwaga : gdy aplikacja jest uruchamiana przy użyciu dotnet run , launchSettings.jsonjest odczytywana, jeśli jest dostępna, a environmentVariablesustawienia w launchSettings.json zastępują zmienne środowiskowe.

Jak Host.CreateDefaultBuilder działa?

.NET Core 3.0 dodane w Host.CreateDefaultBuilderramach rozszerzeń platformy, które zapewnią domyślną inicjalizację, IConfigurationktóra zapewnia domyślną konfigurację aplikacji w następującej kolejności:

  1. appsettings.jsonprzy użyciu dostawcy konfiguracji JSON .
  2. appsettings.Environment.jsonprzy użyciu dostawcy konfiguracji JSON . Na przykład:
    • appsettings.Production.json lub
    • appsettings.Development.json
  3. Sekrety aplikacji gdy aplikacja działa w środowisku programistycznym.
  4. Zmienne środowiskowe korzystające z dostawcy konfiguracji zmiennych środowiskowych .
  5. Argumenty wiersza polecenia przy użyciu dostawcy konfiguracji wiersza polecenia .

Dalsza lektura - MS Docs

KyleMit
źródło
Dzięki, to dobrze, ale Jak to zrobić z procesem konsoli (lub szablonem procesu roboczego / rusztowaniem)?
hB0
To nie działa z najnowszą wersją, zawsze będzie pobierać appsettings.json i ignorować appsettings.development.json. Brakuje również funkcji Run (dev) and run (prod).
user1034912
45

W ASP.NET Core należy raczej używać zmiennych środowiskowych zamiast konfiguracji kompilacji dla prawidłowego appsettings.json

  1. Kliknij prawym przyciskiem myszy projekt> Właściwości> Debugowanie> Zmienne środowiskowe

    Zmienne środowiska

  2. ASP.NET Core użyje odpowiedniego pliku appsettings.json:

    przykład plików appsettings w eksploratorze rozwiązań

  3. Teraz możesz użyć tej zmiennej środowiskowej w następujący sposób:

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

Uwaga : jeśli użyjesz odpowiedzi @ Dmitry , możesz napotkać problemy, np. podczas zastępowania wartości appsettings.json na platformie Azure.

Jonatan Dragon
źródło
35

Możesz użyć zmiennych środowiskowych i ConfigurationBuilderklasy w swoim Startupkonstruktorze w następujący sposób:

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

Następnie tworzysz appsettings.xxx.jsonplik dla każdego potrzebnego środowiska, gdzie „xxx” to nazwa środowiska. Pamiętaj, że możesz umieścić wszystkie globalne wartości konfiguracyjne w swoim „normalnym”appsettings.json pliku i umieścić w tych nowych plikach tylko elementy specyficzne dla środowiska.

Teraz potrzebujesz tylko zmiennej środowiskowej wywoływanej ASPNETCORE_ENVIRONMENTz określoną wartością środowiskową („na żywo”, „staging”, „produkcja”, cokolwiek). Możesz określić tę zmienną w ustawieniach projektu dla swojego środowiska programistycznego i oczywiście musisz ustawić ją również w środowisku pomostowym i produkcyjnym. Sposób, w jaki to robisz, zależy od tego, jakie to jest środowisko.

AKTUALIZACJA: Właśnie zdałem sobie sprawę, że chcesz wybrać na appsettings.xxx.jsonpodstawie bieżącej konfiguracji kompilacji . Nie da się tego osiągnąć za pomocą proponowanego przeze mnie rozwiązania i nie wiem, czy jest na to sposób. Jednak metoda „zmiennych środowiskowych” działa i równie dobrze może być dobrą alternatywą dla twojego podejścia.

Onkel Toob
źródło
Przyjrzałem się użyciu zmiennych środowiskowych w sekcji właściwości projektu-> debugowanie, jednak nie ma oczywistego sposobu, jak to się zmieni w zależności od ustawień projektu. Czy to kolejny plik, który mogę dodać do mojego projektu, aby go obsłużyć?
meds
Ustawienie zmiennej we właściwościach projektu będzie działać tylko w przypadku używania jej w środowisku programistycznym (prawdopodobnie Visual Studio). Będziesz musiał ustawić go w innym miejscu dla wdrożonych aplikacji w zależności od określonego środowiska (IIS, Azure). Nie polecałbym ustawiania zmiennej w jakimś pliku konfiguracyjnym, ponieważ ten plik może również zostać wdrożony, a następnie przesłonić wartości serwera.
Onkel Toob
Skonfigurowałeś to w konfiguracjach kompilacji. Jeśli nie ma pliku konfiguracyjnego kompilacji, robią to ręcznie, więc musieliby ustawić go w (archaicznym) profilu wdrażania
Nick Turner
Mam wiele środowisk, takich jak testy, staging i produkcja na platformie Azure. Gdzie mogę zmienić zmienną ASPNETCORE_ENVIRONMENT, jeśli chcę opublikować kompilację wersji aplikacji sieci Web z VS na platformę Azure?
mroźny
Nie zmieniamy zmiennych podczas wdrażania, zamiast tego są one wbudowane w określone środowisko. Na platformie Azure można ustawić te wartości bezpośrednio w konfiguracji usługi aplikacji w obszarze „Ustawienia aplikacji”. Nie zapomnij oznaczyć ich jako „Ustawienia miejsca wdrożenia”, jeśli pracujesz z wieloma gniazdami.
Onkel Toob
29

Tylko aktualizacja dla użytkowników .NET core 2.0, możesz określić konfigurację aplikacji po wywołaniu CreateDefaultBuilder:

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

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

   static void ConfigConfiguration(WebHostBuilderContext ctx, IConfigurationBuilder config)
   {
            config.SetBasePath(Directory.GetCurrentDirectory())
                .AddJsonFile("config.json", optional: false, reloadOnChange: true)
                .AddJsonFile($"config.{ctx.HostingEnvironment.EnvironmentName}.json", optional: true, reloadOnChange: true);

   }
 }
umutesen
źródło
2
Jak przełączasz się między używanymi środowiskami? Czy należy wprowadzić zmiany w jakimkolwiek pliku konfiguracyjnym? Rozumiem, że muszę dodać adres URL, którego chcę używać, gdy projekt jest uruchamiany na platformie Azure, do pliku appsettings.json i adres URL, który chcę wykonać, gdy jest uruchamiany lokalnie (przez F5), do pliku appsettings.Development.json . Czy to jest poprawne? Mój ciąg, którego chcę użyć, znajduje się w pliku launchSettings.json i nie jestem pewien, jak go zmienić w zależności od miejsca wykonywania aplikacji (lub czy w ogóle ma zostać zmieniony).
DonkeyBanana
3
@DonkeyBanana Środowisko to nic innego jak ustawienie określone we właściwościach projektu. W VS 2017 kliknij prawym przyciskiem myszy projekt> właściwości. W obszarze debugowania zobaczysz bieżące środowisko klucza ASPNETCORE_ENVIRONMENT. Wartość jest tym, co zostanie zastąpione ctx.HostingEnvironment.EnvironmentName}. Jeśli więc ustawisz tę wartość we właściwościach na „Produkcja”, projekt będzie szukał config.Production.jsonpliku w folderze głównym. Aby uzyskać więcej informacji, kliknij ten link
umutesen
Tworzy Error CS0266 Cannot implicitly convert type 'Microsoft.AspNetCore.Hosting.IWebHost' to 'Microsoft.AspNetCore.Hosting.IWebHostBuilder'. An explicit conversion exists (are you missing a cast?) w WebHost.CreateDefaultBuiler (...
Hecatonchires
Warto zauważyć, że w tym miejscu jest napisane, że „AddJsonFile jest automatycznie wywoływana dwukrotnie, gdy inicjujesz nowy program budujący hosta za pomocą CreateDefaultBuilder”. Innymi słowy, ładuje już appSettings.json, a następnie, w oparciu o konfigurację środowiska, ładuje appsettings. {Environment} .json
David Yates
@umutsen W najnowszym studiu wizualnym nie ma już ustawień środowiska uruchomieniowego
user1034912
13
  1. Utwórz wiele plików, takich jak:appSettings.$(Configuration).json

    • appSettings.staging.json
    • appSettings.production.json
  2. Utwórz wydarzenie przed kompilacją w projekcie, które kopiuje odpowiedni plik do appSettings.json:

    copy appSettings.$(Configuration).json appSettings.json
    
  3. Używaj tylko appSettings.jsonw swoim Config Builder:

    var builder = new ConfigurationBuilder()
                .SetBasePath(env.ContentRootPath)
                .AddJsonFile("appsettings.json", optional: false, reloadOnChange: true)
                .AddEnvironmentVariables();
    
    Configuration = builder.Build();
    
user3924036
źródło
To powinna być akceptowana odpowiedź. W skomplikowanych przypadkach można użyć SlowCheetah .
Anton Krouglov
8

Można dodać nazwę konfiguracji jak ASPNETCORE_ENVIRONMENTw launchSettings.jsonjak poniżej

  "iisSettings": {
    "windowsAuthentication": false,
    "anonymousAuthentication": true,
    "iisExpress": {
      "applicationUrl": "http://localhost:58446/",
      "sslPort": 0
    }
  },
  "profiles": {
    "IIS Express": {
      "commandName": "IISExpress",
      "environmentVariables": {
        ASPNETCORE_ENVIRONMENT": "$(Configuration)"
      }
    }
  }
Fleaca Dan
źródło
3

Ta wersja działa u mnie podczas korzystania z aplikacji konsoli bez strony internetowej:

var builder = new ConfigurationBuilder()
             .SetBasePath(Directory.GetCurrentDirectory())
             .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
             .AddJsonFile($"appsettings.{Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT")}.json", optional: true);

            IConfigurationRoot configuration = builder.Build();
            AppSettings appSettings = new AppSettings();
            configuration.GetSection("AppSettings").Bind(appSettings);
Nick Cordova
źródło
0

Plik .vscode / launch.json jest używany tylko przez program Visual Studio, a także plik /Properties/launchSettings.json. Nie używaj tych plików w środowisku produkcyjnym.

Plik launchSettings.json:

  1. Jest używany tylko na lokalnym komputerze deweloperskim.
  2. Nie jest wdrożony.
  3. zawiera ustawienia profilu.

    • Wartości środowiskowe ustawione w launchSettings.json zastępują wartości ustawione w środowisku systemowym

Na przykład, aby użyć pliku „appSettings.QA.json”. Możesz użyć „ASPNETCORE_ENVIRONMENT”. Wykonaj poniższe kroki.

  1. Dodaj nową zmienną środowiskową na komputerze hosta i nazwij ją „ASPNETCORE_ENVIRONMENT”. Ustaw jego wartość na „QA”.
  2. Utwórz plik „appSettings.QA.json” w swoim projekcie. Dodaj swoją konfigurację tutaj.
  3. Wdróż na komputerze w kroku 1. Upewnij się, że „appSettings.QA.json” jest wdrożona.
  4. Załaduj swoją witrynę. Spodziewaj się użycia tutaj appSettings.QA.json.
Oks Xen
źródło