ASP.NET Core es un potente marco de trabajo desarrollado por Microsoft para crear aplicaciones web modernas y escalables. Una de las características fundamentales que lo hacen versátil y adaptable a diversos escenarios es su sistema de configuración. La configuración en ASP.NET Core permite que las aplicaciones se comporten de manera diferente según los entornos en los que se ejecutan, evitando la necesidad de recompilar el código para cambiar ciertos parámetros. En este extenso texto, exploraremos a fondo la configuración de ASP.NET Core y cómo aprovecharla al máximo para mejorar la modularidad y la flexibilidad de nuestras aplicaciones.
1 Conceptos básicos de configuración en ASP.NET Core
1.1. ¿Qué es la configuración en ASP.NET Core? ASP.NET Core proporciona un mecanismo para cargar configuraciones externas en una aplicación web. Esto implica que los valores de configuración, como cadenas de conexión a bases de datos, URL de servicios externos, valores de autenticación y otros parámetros, se almacenan fuera del código fuente de la aplicación. La idea es que estos valores pueden ser modificados sin necesidad de recompilar la aplicación, lo que facilita el mantenimiento y la administración de las diferentes configuraciones en los distintos entornos de uso (desarrollo, pruebas, producción, etc.).
1.2. Configuración de proveedores En ASP.NET Core, los valores de configuración se obtienen a través de proveedores. Un proveedor es una fuente de datos que proporciona los valores de configuración. Los proveedores más comunes son:
- Proveedor de archivos JSON: Lee los valores de un archivo JSON.
- Proveedor de variables de entorno: Obtiene los valores de las variables del sistema operativo o variables de entorno.
- Proveedor de línea de comandos: Permite sobrescribir los valores de configuración desde la línea de comandos al iniciar la aplicación.
- Proveedor de configuración en memoria: Permite agregar valores de configuración directamente desde el código.
1.3. Configuración de proveedores en el inicio de la aplicación La configuración en ASP.NET Core se establece al inicio de la aplicación en la clase Program.cs. Aquí es donde se configura el WebHostBuildery se especifican los proveedores de configuración. Veamos un ejemplo de cómo se realiza esto:
public class Program
{
public static void Main(string[] args)
{
CreateHostBuilder(args).Build().Run();
}
public static IHostBuilder CreateHostBuilder(string[] args) =>
Host.CreateDefaultBuilder(args)
.ConfigureAppConfiguration((hostingContext, config) =>
{
config.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true);
config.AddJsonFile($"appsettings.{hostingContext.HostingEnvironment.EnvironmentName}.json", optional: true, reloadOnChange: true);
config.AddEnvironmentVariables();
if (args != null)
{
config.AddCommandLine(args);
}
})
.ConfigureWebHostDefaults(webBuilder =>
{
webBuilder.UseStartup<Startup>();
});
}
En este ejemplo, hemos agregado el proveedor de archivos JSON mediante config.AddJsonFile, que carga la configuración desde appsettings.json. Además, también se agrega otro proveedor de archivos JSON específico del entorno actual, como appsettings.Production.jsonsi el entorno es “Producción”. Luego, se agrega el proveedor de variables de entorno mediante config.AddEnvironmentVariables()y el proveedor de línea de comandos mediante config.AddCommandLine(args).
2 Estructura de archivos de configuracion
Los archivos de configuración son fundamentales para almacenar los valores de configuración de la aplicación en ASP.NET Core. Veamos la estructura típica de los archivos de configuración más comunes:
2.1. appsettings.json El archivo appsettings.jsones el archivo de configuración principal y contiene valores que son comunes a todos los entornos (desarrollo, producción, etc.). Un ejemplo de appsettings.jsonseria:
{
"Logging": {
"LogLevel": {
"Default": "Information",
"Microsoft": "Warning",
"Microsoft.Hosting.Lifetime": "Information"
}
},
"AllowedHosts": "*",
"ConnectionStrings": {
"DefaultConnection": "Data Source=mydatabase.db"
}
}
En este ejemplo, tenemos configuraciones para el registro de eventos ( Logging), las direcciones permitidas para hosting ( AllowedHosts), y una cadena de conexión a una base de datos ( ConnectionStrings).
2.2. appsettings.{Environment}.json Además del appsettings.json, podemos tener archivos específicos para cada entorno. Por ejemplo, si estamos en el entorno de producción, podemos crear un archivo appsettings.Production.jsoncon valores específicos para ese entorno:
{
"Logging": {
"LogLevel": {
"Default": "Warning"
}
},
"AllowedHosts": "myproductiondomain.com"
}
En este ejemplo, se ha ajustado el nivel de registro para el entorno de producción y se ha restringido el acceso solo a myproductiondomain.com.
3 Prioridad de proveedores de configuracion
Los proveedores de configuración tienen una jerarquía para cargar los valores, y la prioridad de los proveedores afecta qué valor se confirma finalmente para una determinada clave de configuración. El orden de prioridad, de mayor a menor, es el siguiente:
- Proveedor de línea de comandos
- Proveedor de variables de entorno
- Proveedor de archivos de configuración específicos del entorno (appsettings.{Environment}.json)
- Proveedor de archivos de configuración principal (appsettings.json)
- Proveedor de configuracion en memoria
Por ejemplo, si una clave de configuración se encuentra tanto en el archivo appsettings.jsoncomo en las variables de entorno, la versión de la variable de entorno tendrá prioridad.
4 Accediendo a la configuración en el código
Una vez que la configuración se ha cargado y construido en el inicio de la aplicación, podemos acceder a ella en cualquier parte del código. Para ello, podemos usar la interfaz IConfiguration, que está disponible a través de la inyección de dependencias en ASP.NET Core.
using Microsoft.Extensions.Configuration;
public class MyService
{
private readonly IConfiguration _configuration;
public MyService(IConfiguration configuration)
{
_configuration = configuration;
}
public void DoSomething()
{
var connectionString = _configuration.GetConnectionString("DefaultConnection");
var logLevel = _configuration["Logging:LogLevel:Default"];
// ...
}
}
En este ejemplo, se muestra cómo inyectar IConfigurationen un servicio y luego utilizarlo para obtener la cadena de conexión y el nivel de
5 Opciones y modelos de configuración
Hasta ahora, hemos visto cómo acceder a valores individualesIConfigurationpero
5.1. Opciones de configuracion
Las
public class MyOptions
{
{
{
public string ConnectionString { get; set; }
public LogLevelOptions LogLevel { get; set; }
}
public class LogLevelOptions
{
{
{
public string Default { get; set; }
public string Microsoft { get; set; }
public string MicrosoftHostingLifetime { get; set; }
}
Luego, en elStartup.cs, podemos configurar estas opciones usando IConfigurationy el métodoConfigure:
public class Startup
{
public IConfiguration Configuration { get; }
public Startup(IConfiguration configuration)
{
Configuration = configuration;
}
{
Configuration = configuration;
public void ConfigureServices(IServiceCollection services)
{
services.Configure<MyOptions>(Configuration);
{
{
// ...
}
}
AhMyOptionsen cualquier servicio o componente y acceder a
public class MyService
{
{
private readonly MyOptions _options;
public MyService(IOptions<MyOptions> options)
{
_options = options.Value;
}
{
_options = options.Value;
}
{
_options = options.Value;
}
public void DoSomething()
{
{
{
var connectionString = _options.ConnectionString;
var logLevel = _options.LogLevel.Default;
// ...
}
}
5
Si la configura
Por ejemplo, si tenemos la siguiente configuración:
{
"MySection": {
"Option1": "Value1",
"Option2": "Value2"
}
}
Vaina
public class MyConfigModel
{
{
public MySection MySection { get; set; }
}
public class MySection
{
{
{
public string Option1 { get; set; }
public string Option2 { get; set; }
}
}
``
LStartup.cs:
public class Startup
{
{
{
public IConfiguration Configuration { get; }
public Startup(IConfiguration configuration)
{
Configuration = configuration;
}
{
Configuration = configuration;
}
{
public void ConfigureServices(IServiceCollection services)
{
services.Configure<MyConfigModel>(Configuration);
{
// ...
}
}
}
}
``
Y, finalmente, en
public class MyService
{
{
private readonly MyConfigModel _configModel;
public MyService(IOptions<MyConfigModel> configModel)
{
_configModel = configModel.Value;
}
{
public void DoSomething()
{
{
var option1Value = _configModel.MySection.Option1;
var option2Value = _configModel.MySection.Option2;
// ...
}
}
6 Configuración segura
En muchas aplicaciones, es comun tener configuracion
6.1. User Secrets User Secrets es una característica de desarrollo que permite almacenar datos confidenciales de forma segura durante la fase de desarrollo
PasoMicrosoft.Extensions.Configuration.UserSecrets.
Paso 2: Habsecrets.json, donde podemos agregar nuestros secretos:
{
"MySecret": "MySecretValue"
}
Paso 3: Leer secretoStartup.cs, podemos agregar los secretos a la configuración de la siguiente manera:
public class Startup
{
public IConfiguration Configuration { get; }
public Startup(IConfiguration configuration)
{
Configuration = configuration;
}
public void ConfigureServices(IServiceCollection services)
{
services.Configure<MyOptions>(Configuration);
{
services.Configure<MyOptions>(Configuration);
{
// ...
}
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
// ...
var mySecretValue = Configuration["MySecret"];
// ...
}
}
Luego, en el Startup.cs, podemos agregar la configuración de Key Vault utilizando `AzureKeyVaultConfigurationAzureKeyVaultConfigurationExtensions:
public class Startup
{
public IConfiguration Configuration { get; }
public Startup(IConfiguration configuration)
{
Configuration = configuration;
}
{
Configuration = configuration;
}
{
public void ConfigureServices(IServiceCollection services)
{
services.Configure<MyOptions>(Configuration);
{
// ...
}
}
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
// ...
var keyVaultEndpoint = Configuration["KeyVault:Endpoint"];
if (!string.IsNullOrEmpty(keyVaultEndpoint))
{
var azureServiceTokenProvider = new AzureServiceTokenProvider();
var keyVaultClient = new KeyVaultClient(
new KeyVaultClient.AuthenticationCallback(azureServiceTokenProvider.KeyVaultTokenCallback));
config.AddAzureKeyVault(keyVaultEndpoint, keyVaultClient, new DefaultKeyVaultSecretManager());
}
// ...
}
}
En este ejemplo, estamos leyendo la URL del endpoint de Key Vault desdeAddAzureKeyVault.
7 Configuración en diferentes entornos
Para configurar diferentes entornos, podemosASPNETCORE_ENVIRONMENT. de forma es
setx ASPNETCORE_ENVIRONMENT "Production"
En Linux o macOS
export ASPNETCORE_ENVIRONMENT=Production
AdemáslaunchSettings.jsonen el proyecto de la aplicacion:
{
"profiles": {
"Production": {
"commandName": "Project",
"environmentVariables": {
"ASPNETCORE_ENVIRONMENT": "Production"
}
}
}
}
Estafaappsettings.{Environment}.jsoncorresponderASPNETCORE_ENVIRONMENT.
8 Sobrescribiendo
A
El monitor de opciones permite que una clase observadora escuche los cambios en las opciones de configuración y reaccione enIOptionsMonitor<TOptions>en nuestro servicio y suscribirnos al evento OnChange:
public class MyService
{
{
{
private readonly IOptionsMonitor<MyOptions> _optionsMonitor;
public MyService(IOptionsMonitor<MyOptions> optionsMonitor)
{
_optionsMonitor = optionsMonitor;
_optionsMonitor.OnChange(OptionsOnChange);
}
{
_optionsMonitor = options
{
private void OptionsOnChange(MyOptions options)
{
{
// React to configuration changes
// ...
}
// ...
}
AhOptionsOnChangese ejecutará automáticamente.
9 Configuracion de multiples proveedores
esappsettings.json, que luego se sobrescribe con valoresappsettings.{Environment}.json. Además, podemos agregar
Para lograr esto, simplemente podemos agregar múltiples proveedores de configuración en el Program.cs:
public class Program
{
public static void Main(string[] args)
{
CreateHostBuilder(args).Build().Run();
}
{
CreateHostBuilder(args).Build().Run();
}
{
CreateHostBuilder(args).Build().Run
{
{
public static IHostBuilder CreateHostBuilder(string[] args) =>
Host.CreateDefaultBuilder(args)
.ConfigureAppConfiguration((hostingContext, config) =>
{
config.AddJsonFile(
Host.CreateDefaultBuilder(args)
.ConfigureAppConfiguration((hostingContext, config) =>
{
Host.CreateDefaultBuilder(args)
"appsettings.json", optional: true, reloadOnChange: true);
config.AddJsonFile($"appsettings.{hostingContext.HostingEnvironment.EnvironmentName}.json", optional: true, reloadOnChange: true);
config.AddEnvironmentVariables();
if (args != null)
{
config.AddCommandLine(args);
}
})
.ConfigureWebHostDefaults(webBuilder =>
{
webBuilder.UseStartup<Startup>();
});
}
{
config.AddCommandLine(args);
}
})
.ConfigureWebHostDefaults(webBuilder =>
{
{
config.AddCommandLine(args);
}
})En conclución: La configuración en ASP.NET Core es una característica poderosa que permite que las aplicaciones sean más flexibles y adaptables a diferentes entornos. Mediante el uso de proveedores de configuración, opciones y modelos, podemos organizar y acceder a la configuración de una manera estructurada y segura. Además, la posibilidad de sobrescribir la configuración en tiempo de ejecución nos brinda la capacidad de cambiar ciertos valores sin necesidad de reiniciar la aplicación.
En resumen, aproveche al máximo la configuración en ASP.NET Core es esencial para el desarrollo de aplicaciones modernas y escalables. Con una configuración adecuada, nuestras aplicaciones serán más fáciles de mantener y administrar, lo que se traducirá en una experiencia más fluida para los usuarios y una mayor eficiencia para los equipos de desarrollo.
