¿Configurar automáticamente appsettings.json para entornos de desarrollo y lanzamiento en asp.net core?

He definido algunos valores en mi appsettings.jsonpara cosas como cadenas de conexión de bases de datos, ubicaciones de webapi y similares, que son diferentes para entornos de desarrollo, puesta en escena y en vivo.

¿Hay alguna manera de tener varios appsettings.jsonarchivos (como appsettings.live.json, etc., etc.) y hacer que la aplicación asp.net simplemente 'sepa' cuál usar en función de la configuración de compilación que se está ejecutando?

Puede utilizar la compilación condicional:

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

He añadido capturas de pantalla de un entorno de trabajo porque me ha costado varias horas de I + D.

1. Primero, agregue una clave a su launch.jsonarchivo.

   Vea la captura de pantalla a continuación, que he agregado Developmentcomo mi entorno.

   

2. Luego, en su proyecto, cree un nuevo appsettings.{environment}.jsonarchivo que incluya el nombre del entorno.

   En la siguiente captura de pantalla, busque dos archivos diferentes con los nombres:

   • appsettings.Development.Json
   • appSetting.json

   
   

3. Y finalmente, configúrelo para su StartUpclase así:

   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. Y por último, puedes ejecutarlo desde la línea de comando así:

   dotnet run --environment "Development"
   

   donde "Development"esta el nombre de mi entorno.

Actualización para .NET Core 3.0+

1. Puede usar CreateDefaultBuilderque automáticamente construirá y pasará un objeto de configuración a su clase de inicio:

   WebHost.CreateDefaultBuilder(args).UseStartup<Startup>();
   

   public class Startup
   {
       public Startup(IConfiguration configuration) // automatically injected
       {
           Configuration = configuration;
       }
       public IConfiguration Configuration { get; }
       /* ... */
   }
   

2. CreateDefaultBuilderincluye automáticamente el archivo apropiado , así que agregue un archivo de configuración de aplicaciones separado para cada entorno:appsettings.Environment.json

   

3. Luego establezca la ASPNETCORE_ENVIRONMENT variable de entorno al ejecutar / depurar

Cómo configurar variables de entorno

Dependiendo de su IDE, hay un par de lugares donde los proyectos de dotnet tradicionalmente buscan variables de entorno:

• Para Visual Studio, vaya a Proyecto> Propiedades> Depurar> Variables de entorno:

  

• Para Visual Studio Code , edite .vscode/launch.json> env:

  

• Usando Configuración de inicio , editar Properties/launchSettings.json> environmentVariables:

  

  Que también se puede seleccionar de la barra de herramientas en Visual Studio

  

• Con la CLI de dotnet , utilice la sintaxis adecuada para configurar las variables de entorno según su sistema operativo

  Nota : Cuando se inicia una aplicación con dotnet run , launchSettings.jsonse lee si está disponible y la environmentVariablesconfiguración en launchSettings.json anula las variables de entorno.

¿Cómo Host.CreateDefaultBuilderfunciona?

Se agregó .NET Core 3.0 Host.CreateDefaultBuilderen las extensiones de plataforma que proporcionarán una inicialización predeterminada IConfigurationque proporciona la configuración predeterminada para la aplicación en el siguiente orden:

1. appsettings.jsonutilizando el proveedor de configuración JSON .
2. appsettings.Environment.jsonutilizando el proveedor de configuración JSON . Por ejemplo:
   • appsettings.Production.json o
   • appsettings.Development.json
3. Secretos de la aplicación cuando la aplicación se ejecuta en el entorno de desarrollo.
4. Variables de entorno que utilizan el proveedor de configuración de Variables de entorno .
5. Argumentos de la línea de comandos que utilizan el proveedor de configuración de la línea de comandos .

Lectura adicional - MS Docs

• Inicio de la aplicación en ASP.NET Core
• Configuración en ASP.NET Core
• Utilice varios entornos en ASP.NET Core

En ASP.NET Core, debería utilizar variables de entorno en lugar de compilar la configuración para appsettings.json adecuada

1. Haga clic derecho en su proyecto> Propiedades> Depurar> Variables de entorno

   

2. ASP.NET Core usará el archivo appsettings.json apropiado:

   

3. Ahora puede usar esa variable de entorno de esta manera:

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

Nota : Si usa la respuesta de @ Dmitry , puede tener problemas, por ejemplo. al invalidar los valores de appsettings.json en Azure.

Puede hacer uso de variables de entorno y la ConfigurationBuilderclase en su Startupconstructor de esta manera:

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

Luego, crea un appsettings.xxx.jsonarchivo para cada entorno que necesita, con "xxx" como nombre del entorno. Tenga en cuenta que puede poner todos los valores de configuración global en su "normal"appsettings.json archivo y solo poner las cosas específicas del entorno en estos nuevos archivos.

Ahora solo necesita una variable de entorno llamada ASPNETCORE_ENVIRONMENTcon algún valor de entorno específico ("en vivo", "puesta en escena", "producción", lo que sea). Puede especificar esta variable en la configuración de su proyecto para su entorno de desarrollo y, por supuesto, también debe establecerla en sus entornos de ensayo y producción. La forma en que lo haga depende del tipo de entorno que sea.

ACTUALIZACIÓN: Me acabo de dar cuenta de que desea elegir el appsettings.xxx.jsonbasado en su configuración de compilación actual . Esto no se puede lograr con mi solución propuesta y no sé si hay una manera de hacerlo. La forma de "variable de entorno", sin embargo, funciona y bien podría ser una buena alternativa a su enfoque.

Solo una actualización para los usuarios de .NET core 2.0, puede especificar la configuración de la aplicación después de la llamada a 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);

   }
 }

1. Crea varios archivos como:appSettings.$(Configuration).json

   • appSettings.staging.json
   • appSettings.production.json

2. Cree un evento previo a la construcción en el proyecto que copie el archivo respectivo en appSettings.json:

   copy appSettings.$(Configuration).json appSettings.json
   

3. Usar unicamente appSettings.json en su Config Builder:

   var builder = new ConfigurationBuilder()
               .SetBasePath(env.ContentRootPath)
               .AddJsonFile("appsettings.json", optional: false, reloadOnChange: true)
               .AddEnvironmentVariables();
   
   Configuration = builder.Build();
   

Se puede añadir el nombre de la configuración como la ASPNETCORE_ENVIRONMENTde la launchSettings.jsonde la siguiente

  "iisSettings": {
    "windowsAuthentication": false,
    "anonymousAuthentication": true,
    "iisExpress": {
      "applicationUrl": "http://localhost:58446/",
      "sslPort": 0
    }
  },
  "profiles": {
    "IIS Express": {
      "commandName": "IISExpress",
      "environmentVariables": {
        ASPNETCORE_ENVIRONMENT": "$(Configuration)"
      }
    }
  }

Esta es la versión que me funciona cuando uso una aplicación de consola sin una página web:

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

El archivo .vscode / launch.json solo lo usa Visual Studio, así como el archivo /Properties/launchSettings.json. No utilice estos archivos en producción.

El archivo launchSettings.json:

1. Solo se usa en la máquina de desarrollo local.
2. No está desplegado.

3. contiene la configuración del perfil.

   • Los valores del entorno establecidos en launchSettings.json anulan los valores establecidos en el entorno del sistema

Para usar un archivo 'appSettings.QA.json', por ejemplo. Puede utilizar 'ASPNETCORE_ENVIRONMENT'. Siga los pasos a continuación.

1. Agregue una nueva variable de entorno en la máquina host y llámela 'ASPNETCORE_ENVIRONMENT'. Establezca su valor en 'QA'.
2. Cree un archivo 'appSettings.QA.json' en su proyecto. Agregue su configuración aquí.
3. Implemente en la máquina en el paso 1. Confirme que 'appSettings.QA.json' esté implementado.
4. Cargue su sitio web. Espere que appSettings.QA.json se use aquí.