asp.net-core
Configuration de plusieurs environnements

Avoir des appsettings par environnement

Pour chaque environnement, vous devez créer un fichier appsettings distinct. {EnvironmentName} .json:

• appsettings.Development.json
• appsettings.Staging.json
• appsettings.Production.json

Ensuite, ouvrez le fichier project.json et incluez-les dans "include" dans la section "publishOptions". Cela répertorie tous les fichiers et dossiers qui seront inclus lorsque vous publiez:

"publishOptions": {
  "include": [
    "appsettings.Development.json",
    "appsettings.Staging.json",
    "appsettings.Production.json"
    ... 
  ]
}

La dernière étape Dans votre classe de démarrage, ajoutez:

.AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true);

dans constructeur où vous définissez les sources de configuration:

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

Obtenir / Vérifier le nom de l'environnement à partir du code

Tout ce dont vous avez besoin est une variable de type IHostingEnvironment :

• obtenir le nom de l'environnement:

    env.EnvironmentName
  

• Prédéfini Development , Staging en Production Staging , Production des environnements est la meilleure façon d'utiliser des méthodes d'extension de HostingEnvironmentExtensions classe

    env.IsDevelopment()
    env.IsStaging()
    env.IsProduction()
  

• ignorez correctement la casse (une autre méthode d’extension de HostingEnvironmentExtensions :

   env.IsEnvironment("environmentname") 
  

• variante sensible à la casse:

   env.EnvironmentName == "Development" 
  

Configuration de plusieurs environnements

Cet exemple montre comment configurer plusieurs environnements avec une configuration d'injection de dépendances différente et des middlewares distincts dans une classe de Startup .

En plus des méthodes public void Configure(IApplicationBuilder app) et public void ConfigureServices(IServiceCollection services) , on peut utiliser Configure{EnvironmentName} et Configure{EnvironmentName}Services pour avoir une configuration dépendante de l'environnement.

L'utilisation de ce modèle évite de mettre beaucoup de logique if/else une seule méthode / classe de Startup et de la garder propre et séparée.

public class Startup
{
    public void ConfigureServices(IServiceCollection services) { }
    public void ConfigureStaggingServices(IServiceCollection services) { }
    public void ConfigureProductionServices(IServiceCollection services) { }
    
    public void Configure(IApplicationBuilder app) { }
    public void ConfigureStagging(IApplicationBuilder app) { }
    public void ConfigureProduction(IApplicationBuilder app) { }
}

Si les services Configure{Environmentname} ou Configure{Environmentname}Services ne sont pas trouvés, ils ConfigureServices respectivement Configure ou ConfigureServices .

La même sémantique s'applique également à la classe Startup . StartupProduction sera utilisé lorsque la ASPNETCORE_ENVIRONMENT variable est définie sur la Production et revenir à Startup quand il est Stagging ou le Development

Un exemple complet:

public class Startup
{
    public Startup(IHostingEnvironment hostEnv)
    {
        // Set up configuration sources.
        var builder = new ConfigurationBuilder()
            .SetBasePath(hostEnv.ContentRootPath)
            .AddJsonFile("appsettings.json", optional: false, reloadOnChange: true)
            .AddJsonFile($"appsettings.{hostEnv.EnvironmentName}.json", optional: true, reloadOnChange: true);

        if (hostEnv.IsDevelopment())
        {
            // This will push telemetry data through Application Insights pipeline faster, allowing you to view results immediately.
            builder.AddApplicationInsightsSettings(developerMode: true);
        }

        builder.AddEnvironmentVariables();
        Configuration = builder.Build();
    }

    public IConfigurationRoot Configuration { get; set; }

    // This method gets called by the runtime. Use this method to add services to the container
    public static void RegisterCommonServices(IServiceCollection services) 
    {
        services.AddScoped<ICommonService, CommonService>();
        services.AddScoped<ICommonRepository, CommonRepository>();
    }
    
    public void ConfigureServices(IServiceCollection services)
    {
        RegisterCommonServices(services);
        
        services.AddOptions();
        services.AddMvc();
    }

    public void ConfigureDevelopment(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory)
    {
        loggerFactory.AddConsole(Configuration.GetSection("Logging"));
        loggerFactory.AddDebug();

        app.UseBrowserLink();
        app.UseDeveloperExceptionPage();

        app.UseApplicationInsightsRequestTelemetry();
        app.UseApplicationInsightsExceptionTelemetry();
        app.UseStaticFiles();
        app.UseMvc();
    }

    // No console Logger and debugging tools in this configuration
    public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory)
    {
        loggerFactory.AddDebug();

        app.UseApplicationInsightsRequestTelemetry();
        app.UseApplicationInsightsExceptionTelemetry();
        app.UseStaticFiles();
        app.UseMvc();
    }
}

Afficher le contenu spécifique de l'environnement dans la vue

Il se peut que vous deviez afficher du contenu dans une vue spécifique à un environnement uniquement. Pour atteindre cet objectif, vous pouvez utiliser l' assistant de balise Environment:

<environment names="Development">
    <h1>This is heading for development environment</h1>
</environment>
<environment names="Staging,Production">
    <h1>This is heading for Staging or production environment</h1>
</environment>

L'assistant de balise Environment restitue uniquement son contenu si l'environnement actuel correspond à l'un des environnements spécifiés à l'aide de l'attribut names .

Définir la variable d'environnement à partir de la ligne de commande

Pour définir l'environnement au Development

SET ASPNETCORE_ENVIRONMENT=Development

L'exécution d'une application Asp.Net Core se fera désormais dans l'environnement défini.

Remarque

1. Il ne devrait y avoir aucun espace avant et après le signe d'égalité = .
2. L'invite de commandes ne doit pas être fermée avant d'exécuter l'application car les paramètres ne sont pas conservés.

Définir la variable d'environnement à partir de PowerShell

Lorsque vous utilisez PowerShell, vous pouvez utiliser setx.exe pour définir les variables d'environnement de manière permanente.

1. Démarrer PowerShell

2. Tapez l'une des options suivantes:

   setx ASPNETCORE_ENVIRONMENT "développement"

   setx ASPNETCORE_ENVIRONMENT "mise en scène"

3. Redémarrer PowerShell

Utiliser ASPNETCORE_ENVIRONMENT depuis web.config

Si vous ne souhaitez pas utiliser ASPNETCORE_ENVIRONMENT à partir de variables d'environnement et l'utiliser depuis web.config de votre application, modifiez le fichier web.config comme ceci -

<aspNetCore processPath=".\WebApplication.exe" arguments="" stdoutLogEnabled="false" stdoutLogFile=".\logs\stdout" forwardWindowsAuthToken="false">
  <environmentVariables>
    <environmentVariable name="ASPNETCORE_ENVIRONMENT" value="Development" />
  </environmentVariables>
</aspNetCore>