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?
Respuestas:
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.
Primero, agregue una clave a su launch.jsonarchivo.
Vea la captura de pantalla a continuación, que he agregado Developmentcomo mi entorno.
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.JsonappSetting.json
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();
}
Y por último, puedes ejecutarlo desde la línea de comando así:
dotnet run --environment "Development"
donde "Development"esta el nombre de mi entorno.
IWebHostEnvironmenten su lugar.
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; }
/* ... */
}
CreateDefaultBuilderincluye automáticamente el archivo apropiado , así que agregue un archivo de configuración de aplicaciones separado para cada entorno:appsettings.Environment.json
Luego establezca la ASPNETCORE_ENVIRONMENT variable de entorno al ejecutar / depurar
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 laenvironmentVariablesconfiguración en launchSettings.json anula las variables de entorno.
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:
appsettings.jsonutilizando el proveedor de configuración JSON .appsettings.Environment.jsonutilizando el proveedor de configuración JSON . Por ejemplo:
appsettings.Production.jsonoappsettings.Development.json- Secretos de la aplicación cuando la aplicación se ejecuta en el entorno de desarrollo.
- Variables de entorno que utilizan el proveedor de configuración de Variables de entorno .
- Argumentos de la línea de comandos que utilizan el proveedor de configuración de la línea de comandos .
En ASP.NET Core, debería utilizar variables de entorno en lugar de compilar la configuración para appsettings.json adecuada
Haga clic derecho en su proyecto> Propiedades> Depurar> Variables de entorno
ASP.NET Core usará el archivo appsettings.json apropiado:
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);
}
}
ASPNETCORE_ENVIRONMENT. El valor es lo que será reemplazado ctx.HostingEnvironment.EnvironmentName}. Entonces, si establece ese valor en las propiedades en 'Producción', el proyecto buscará el config.Production.jsonarchivo en la carpeta raíz. Para obtener más información, consulte este enlace
Error CS0266 Cannot implicitly convert type 'Microsoft.AspNetCore.Hosting.IWebHost' to 'Microsoft.AspNetCore.Hosting.IWebHostBuilder'. An explicit conversion exists (are you missing a cast?) WebHost.CreateDefaultBuiler (...
Crea varios archivos como:appSettings.$(Configuration).json
appSettings.staging.jsonappSettings.production.jsonCree un evento previo a la construcción en el proyecto que copie el archivo respectivo en appSettings.json:
copy appSettings.$(Configuration).json appSettings.json
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:
contiene la configuración del perfil.
Para usar un archivo 'appSettings.QA.json', por ejemplo. Puede utilizar 'ASPNETCORE_ENVIRONMENT'. Siga los pasos a continuación.