Comment définir le nom de l'environnement (IHostingEnvironment.EnvironmentName)?
Le projet Web ASP.NET Core par défaut contient de telles lignes dans Startup.cs:
if (string.Equals(env.EnvironmentName, "Development", StringComparison.OrdinalIgnoreCase))
{
app.UseBrowserLink();
app.UseErrorPage(ErrorPageOptions.ShowAll);
}
else
{
app.UseErrorHandler("/Home/Error");
}
Si je comprends bien, EnvironmentName est une nouvelle façon de gérer l’environnement Dev/Production. Mais cela ne change pas sur la configuration de build de Release. Alors, quel est le moyen de définir une EnvironmentName différente?
Je peux imaginer que cela devrait être défini dans "Commandes" en tant que paramètre pour le serveur.
launchsettings.json
Dans Propriétés> launchsettings.json
Juste comme ça:
{
"iisSettings": {
"windowsAuthentication": false,
"anonymousAuthentication": true,
"iisExpress": {
"applicationUrl": "http://localhost:1032/",
"sslPort": 0
}
},
"profiles": {
"IIS Express": {
"commandName": "IISExpress",
"launchBrowser": true,
"environmentVariables": {
"ASPNETCORE_ENVIRONMENT": "Production"
}
},
"WebAppNetCore": {
"commandName": "Project",
"launchBrowser": true,
"launchUrl": "http://localhost:5000",
"environmentVariables": {
"ASPNETCORE_ENVIRONMENT": "Development"
}
},
"web": {
"commandName": "web",
"environmentVariables": {
"ASPNETCORE_ENVIRONMENT": "Development"
}
}
}
}
Après RC2
Alors, comment définir un nom d'environnement différent?
Définissez la variable d'environnement ASPNETCORE_ENVIRONMENT.
Il y a plusieurs façons de définir cette variable environnementale. Ceux-ci incluent un profil launchSettings.json et d'autres méthodes spécifiques à l'environnement . Voici quelques exemples.
À partir d'une console:
// PowerShell
> $env:ASPNETCORE_ENVIRONMENT="Development"
// Windows Command Line
> SET ASPNETCORE_ENVIRONMENT=Development
// Bash
> ASPNETCORE_ENVIRONMENT=Development
Depuis les paramètres de l'application Azure Web App:
Avant RC2
Je peux imaginer que cela devrait être défini dans "Commandes" en tant que paramètre pour le serveur.
C'est vrai. Dans votre projet.json, ajoutez --ASPNET_ENV production en tant que paramètre du serveur.
"commands": {
"web": "Microsoft.AspNet.Hosting --ASPNET_ENV production --server Microsoft.AspNet.Server.WebListener --server.urls http://localhost:5001"
}
Désormais, lorsque vous exécutez dnx . web à partir de la ligne de commande, ASPNET_ENV sera production.
Code source d'hébergement central ASP.NET pertinent
La WebHostBuilder combine "ASPNETCORE_" avec le WebHostDefaults.EnvironmentKey pour créer "ASPNETCORE_environment". Il prend également en charge les clés héritées.
namespace Microsoft.AspNetCore.Hosting
{
public static class WebHostDefaults
{
public static readonly string ApplicationKey = "applicationName";
public static readonly string StartupAssemblyKey = "startupAssembly";
public static readonly string DetailedErrorsKey = "detailedErrors";
public static readonly string EnvironmentKey = "environment";
public static readonly string WebRootKey = "webroot";
public static readonly string CaptureStartupErrorsKey = "captureStartupErrors";
public static readonly string ServerUrlsKey = "urls";
public static readonly string ContentRootKey = "contentRoot";
}
}
_config = new ConfigurationBuilder()
.AddEnvironmentVariables(prefix: "ASPNETCORE_")
.Build();
if (string.IsNullOrEmpty(GetSetting(WebHostDefaults.EnvironmentKey)))
{
// Try adding legacy environment keys, never remove these.
UseSetting(WebHostDefaults.EnvironmentKey,
Environment.GetEnvironmentVariable("Hosting:Environment")
?? Environment.GetEnvironmentVariable("ASPNET_ENV"));
}
Rétrocompatibilité
La clé d'environnement est définie avec la variable d'environnement
ASPNETCORE_ENVIRONMENT.ASPNET_ENVetHosting:Environmentsont toujours pris en charge, mais génèrent un avertissement de message obsolète.
https://docs.asp.net/fr/latest/migration/rc1-to-rtm.html
Valeur par défaut
La valeur par défaut est "Production" et est définie ici.
Vous définissez l'environnement en définissant une variable d'environnement nommée ASPNET_ENV..__, par exemple, si vous souhaitez la version SET ASPNET_ENV=Release.
Cela pourrait également fonctionner si vous transmettez ASPNET_ENV=Release comme paramètre aux commandes, mais je ne peux pas le vérifier maintenant.
Voici comment cela est implémenté: https://github.com/aspnet/Hosting/blob/217f9ca3d3ccf59ea06e6555820974ba9c3b5932/src/Microsoft.AspNet.Hosting/ConfigureHostingEnvironment.cs
J'ai eu le même problème. Pour être indépendant de la variable d'environnement et de web.config, j'ai créé un fichier .json ainsi nommé (je l'ai appelé env settings.json ):
{
// Possible string values reported below.
// - Production
// - Staging
// - Development
"ASPNETCORE_ENVIRONMENT": "Staging"
}
Puis dans Program.cs j'ai ajouté:
public class Program
{
public static void Main(string[] args)
{
var currentDirectoryPath = Directory.GetCurrentDirectory();
var envSettingsPath = Path.Combine(currentDirectoryPath, "envsettings.json");
var envSettings = JObject.Parse(File.ReadAllText(envSettingsPath));
var enviromentValue = envSettings["ASPNETCORE_ENVIRONMENT"].ToString();
var webHostBuilder = new WebHostBuilder()
.UseKestrel()
.CaptureStartupErrors(true)
.UseSetting("detailedErrors", "true")
.UseContentRoot(currentDirectoryPath)
.UseIISIntegration()
.UseStartup<Startup>();
// If none is set it use Operative System hosting enviroment
if (!string.IsNullOrWhiteSpace(enviromentValue))
{
webHostBuilder.UseEnvironment(enviromentValue);
}
var Host = webHostBuilder.Build();
Host.Run();
}
}
Si vous préférez utiliser les fonctionnalités VS (par exemple VS 2017), il est possible d'ajouter des variables d'environnement dans l'onglet Débogage des propriétés du projet. Par exemple, dans les dernières versions d'ASP.NET Core (après RC2), vous devez définir la variable ASPNETCORE_ENVIRONMENT.
En conséquence, le fichier launchSettings.json sera créé (ou mis à jour) dans le dossier Properties du projet correspondant. Il sera donc facile de conserver ce fichier dans votre solution de contrôle de code source et de le partager entre développeurs (contrairement à d'autres solutions). avec les commandes SETSETX)
Remarque: par défaut, la dernière version d'ASP.NET Core définit l'environnement sur Production. Ainsi, il vous suffit de définir ASPNETCORE_ENVIRONMENT sur Development dans VS à des fins de débogage (voir la capture d'écran ci-dessus). Et bien sûr, lorsque vous souhaitez exécuter votre code localement avec l'environnement de stockage intermédiaire, vous devez définir ASPNETCORE_ENVIRONMENT sur Staging. Enfin, lorsque vous souhaitez l'exécuter dans un environnement de production, supprimez simplement cette variable ou définissez la valeur sur Production.
Pour résumer: assurez-vous simplement que les valeurs _/Development, Staging ou Production sont utilisées (pas «Dev» ou autre) dans la boîte de dialogue Débogage pour définir l'environnement et rendre différentes extensions opérationnelles.
Voir aussi le code source pertinent d'ASP.NET Core:
namespace Microsoft.AspNetCore.Hosting
{
/// <summary>Commonly used environment names.</summary>
public static class EnvironmentName
{
public static readonly string Development = "Development";
public static readonly string Staging = "Staging";
public static readonly string Production = "Production";
}
}
namespace Microsoft.AspNetCore.Hosting
{
/// <summary>
/// Extension methods for <see cref="T:Microsoft.AspNetCore.Hosting.IHostingEnvironment" />.
/// </summary>
public static class HostingEnvironmentExtensions
{
/// <summary>
/// Checks if the current hosting environment name is "Development".
/// </summary>
/// <param name="hostingEnvironment">An instance of <see cref="T:Microsoft.AspNetCore.Hosting.IHostingEnvironment" />.</param>
/// <returns>True if the environment name is "Development", otherwise false.</returns>
public static bool IsDevelopment(this IHostingEnvironment hostingEnvironment)
{
if (hostingEnvironment == null)
throw new ArgumentNullException("hostingEnvironment");
return hostingEnvironment.IsEnvironment(EnvironmentName.Development);
}
/// <summary>
/// Checks if the current hosting environment name is "Staging".
/// </summary>
/// <param name="hostingEnvironment">An instance of <see cref="T:Microsoft.AspNetCore.Hosting.IHostingEnvironment" />.</param>
/// <returns>True if the environment name is "Staging", otherwise false.</returns>
public static bool IsStaging(this IHostingEnvironment hostingEnvironment)
{
if (hostingEnvironment == null)
throw new ArgumentNullException("hostingEnvironment");
return hostingEnvironment.IsEnvironment(EnvironmentName.Staging);
}
/// <summary>
/// Checks if the current hosting environment name is "Production".
/// </summary>
/// <param name="hostingEnvironment">An instance of <see cref="T:Microsoft.AspNetCore.Hosting.IHostingEnvironment" />.</param>
/// <returns>True if the environment name is "Production", otherwise false.</returns>
public static bool IsProduction(this IHostingEnvironment hostingEnvironment)
{
if (hostingEnvironment == null)
throw new ArgumentNullException("hostingEnvironment");
return hostingEnvironment.IsEnvironment(EnvironmentName.Production);
}
/// <summary>
/// Compares the current hosting environment name against the specified value.
/// </summary>
/// <param name="hostingEnvironment">An instance of <see cref="T:Microsoft.AspNetCore.Hosting.IHostingEnvironment" />.</param>
/// <param name="environmentName">Environment name to validate against.</param>
/// <returns>True if the specified name is the same as the current environment, otherwise false.</returns>
public static bool IsEnvironment(this IHostingEnvironment hostingEnvironment, string environmentName)
{
if (hostingEnvironment == null)
throw new ArgumentNullException("hostingEnvironment");
return string.Equals(hostingEnvironment.EnvironmentName, environmentName, StringComparison.OrdinalIgnoreCase);
}
}
}
Dans ASP.NET Core RC2, le nom de la variable a été remplacé par ASPNETCORE_ENVIRONMENT
par exemple. Sous Windows, vous pouvez exécuter cette commande sur le serveur de transfert (avec des droits d'administrateur).
SETX ASPNETCORE_ENVIRONMENT "Staging" /M
Cela ne doit être exécuté qu'une seule fois et après cela, le serveur sera toujours considéré comme le serveur de transfert.
Lorsque vous faites un dotnet run dans la commande Invite sur ce serveur, vous verrez Hosting environment: Staging
Si vous pensez que d'où il prend cette valeur, alors en ce moment, il est statique et la valeur par défaut est le développement.
https://github.com/aspnet/Hosting/blob/dev/src/Microsoft.AspNet.Hosting/HostingEnvironment.cs
Lorsque vous examinez le type de variable IHostingEnviroment, il s'agit de Microsoft.AspNet.Hosting.HostingEnvrioment.
Vous pouvez maintenant changer selon la configuration dynamique de deux manières.
Vous pouvez implémenter l'interface IHostingEnvironment et utiliser votre propre type pour cela. Vous pouvez lire la valeur du fichier de configuration.
Vous pouvez utiliser l'interface. Vous pouvez mettre à jour cette variable directement ici.
public Startup(IHostingEnvironment env) { // Setup configuration sources. Configuration = new Configuration() .AddJsonFile("config.json").AddEnvironmentVariables(); Configuration.Set("ASPNET_ENV","Your own value"); }Si vous examinez les services dans ConfigureServices, il existe une liste de services configurés par défaut et l'un d'entre eux est IConfigureHostingEnviroment. L'implémentation par défaut est une classe interne, vous ne pouvez donc pas y accéder directement, mais vous pouvez définir la clé ci-dessus ASPNET_ENV et la lire.
Sur Azure, définissez simplement ASPNET_ENV variable d’environnement sur la page de configuration de l’application Web.
Avec votre propre IIS ou d’autres fournisseurs d’hébergement, modifiez web.config pour inclure les arguments de la commande "web":
<configuration> <system.webServer> <handlers> <add name="httpplatformhandler" path="*" verb="*" modules="httpPlatformHandler" resourceType="Unspecified" /> </handlers> <httpPlatform processPath="..\approot\web.cmd" arguments="--ASPNET_ENV Development" stdoutLogEnabled="false" stdoutLogFile="..\logs\stdout.log" startupTimeLimit="3600"></httpPlatform> </system.webServer> </configuration>Pendant le développement (si vous pouvez modifier le code source), vous pouvez également créer un fichier nommé Microsoft.AspNet.Hosting.json dans une racine de votre projet et définir la variable ASPNET_ENV.
{ "ASPNET_ENV": "Test" }
si vous devez définir ceci sans changer le code - à partir de la commande Invite à la racine du type de dossier source du projet:
set ASPNET_ENV=Debug
Dans VsCode ajoutez ce qui suit à launch.json
{
"version": "0.2.0",
"configurations": [
{
...
"env": {
"ASPNETCORE_ENVIRONMENT": "Development"
}
},
...
]
}
Voici encore une façon de définir _ et changez la variable ASPNETCORE_ENVIRONMENT dans VS2017 (note complémentaire de @ clark-wu answer):
Remarque: launchSettings.json a deux profils dans mon cas: "IISExpress" et "Project" où ASPNETCORE_ENVIRONMENT est défini.
{
"iisSettings": {
"windowsAuthentication": false,
"anonymousAuthentication": true,
"iisExpress": {
"applicationUrl": "http://localhost:10000/",
"sslPort": 0
}
},
"profiles": {
"IIS Express": {
"commandName": "IISExpress",
"launchBrowser": true,
"launchUrl": "api/entities",
"environmentVariables": {
"ASPNETCORE_ENVIRONMENT": "Development" // <-- related to IIS Express profile
}
},
"Project": {
"commandName": "Project",
"launchBrowser": true,
"launchUrl": "api/entities",
"environmentVariables": {
"ASPNETCORE_ENVIRONMENT": "Production" // <-- related to Project profile
},
"applicationUrl": "http://localhost:10000/"
}
}
}
Documentation officielle : Vous pouvez définir ASPNETCORE_ENVIRONMENT sur n'importe quelle valeur, mais trois valeurs sont prises en charge par le cadre: développement, transfert et production. Si ASPNETCORE_ENVIRONMENT n'est pas défini, la valeur par défaut est Production.