comment définir ASPNETCORE_ENVIRONMENT à prendre en compte pour la publication d'une application principale asp.net?

lorsque je publie mon application Web principale asp.net sur mon système de fichiers local, il prend toujours la variable production-config et ASPNETCORE_ENVIRONMENT avec la valeur = "Production".

comment et où dois-je définir la valeur de la variable ASPNETCORE_ENVIRONMENT afin qu'elle soit prise en compte non seulement pour le débogage, mais aussi pour la publication ? j'ai déjà essayé les options suivantes sans succès:

• dans les paramètres de Windows
• dans un fichier .pubxml
• dans launchSettings.json
• dans project.json

Outre les options mentionnées ci-dessus, il existe quelques autres solutions.

1. Modification du fichier de projet (.CsProj)

MSBuild prend en charge la EnvironmentNamepropriété qui peut vous aider à définir la bonne variable d'environnement selon l'environnement que vous souhaitez déployer. Le nom de l'environnement serait ajouté dans le web.config lors de la phase de publication.

Ouvrez simplement le fichier de projet (* .csProj) et ajoutez le XML suivant.

<!-- Custom Property Group added to add the Environment name during publish
  The EnvironmentName property is used during the publish for the Environment variable in web.config
  -->
  <PropertyGroup Condition=" '$(Configuration)' == '' Or '$(Configuration)' == 'Debug'">
    <EnvironmentName>Development</EnvironmentName>
  </PropertyGroup>
  <PropertyGroup Condition=" '$(Configuration)' != '' AND '$(Configuration)' != 'Debug' ">
    <EnvironmentName>Production</EnvironmentName>
  </PropertyGroup>

Le code ci-dessus ajouterait le nom de l'environnement comme Developmentpour la configuration de débogage ou si aucune configuration n'est spécifiée. Pour toute autre configuration, le nom de l'environnement se trouverait Productiondans le fichier web.config généré. Plus de détails ici

2. Ajout de la propriété EnvironmentName dans les profils de publication.

Nous pouvons également ajouter la <EnvironmentName>propriété dans le profil de publication. Ouvrez le fichier de profil de publication qui se trouve dans le Properties/PublishProfiles/{profilename.pubxml}champ Cela définira le nom de l'environnement dans web.config lors de la publication du projet. Plus de détails ici

<PropertyGroup>
  <EnvironmentName>Development</EnvironmentName>
</PropertyGroup>

3. Options de ligne de commande utilisant dotnet publish

De plus, nous pouvons transmettre la propriété en EnvironmentNametant qu'option de ligne de commande à la dotnet publishcommande. La commande suivante inclurait la variable d'environnement comme Developmentdans le fichier web.config.

dotnet publish -c Debug -r win-x64 /p:EnvironmentName=Development

Option 1:

Pour définir la variable d'environnement ASPNETCORE_ENVIRONMENT dans Windows,

Ligne de commande - setx ASPNETCORE_ENVIRONMENT "Development"

PowerShell - $Env:ASPNETCORE_ENVIRONMENT = "Development"

Pour les autres systèmes d'exploitation, reportez-vous à ceci - https://docs.microsoft.com/en-us/aspnet/core/fundamentals/environments

Option 2:

Si vous souhaitez définir ASPNETCORE_ENVIRONMENT en utilisant, web.configajoutez aspNetCorecomme ceci-

<configuration>
  <!--
    Configure your application settings in appsettings.json. Learn more at http://go.microsoft.com/fwlink/?LinkId=786380
  -->
  <system.webServer>
    <handlers>
      <add name="aspNetCore" path="*" verb="*" modules="AspNetCoreModule" resourceType="Unspecified" />
    </handlers>
    <aspNetCore processPath=".\MyApplication.exe" arguments="" stdoutLogEnabled="false" stdoutLogFile=".\logs\stdout" forwardWindowsAuthToken="false">
      <environmentVariables>
        <environmentVariable name="ASPNETCORE_ENVIRONMENT" value="Development" />
      </environmentVariables>
    </aspNetCore>
  </system.webServer>
</configuration>

Un moyen simple de le définir dans l'IDE de Visual Studio.

Projet> Propriétés> Débogage> Variables d'environnement

Vous devez suivre les instructions fournies dans la documentation , en utilisant le web.config.

<aspNetCore processPath="dotnet"
        arguments=".\MyApp.dll"
        stdoutLogEnabled="false"
        stdoutLogFile="\\?\%home%\LogFiles\aspnetcore-stdout">
  <environmentVariables>
    <environmentVariable name="ASPNETCORE_ENVIRONMENT" value="Production" />
    <environmentVariable name="CONFIG_DIR" value="f:\application_config" />
  </environmentVariables>
</aspNetCore>

Notez que vous pouvez également définir d'autres variables d'environnement.

Le module ASP.NET Core vous permet de spécifier des variables d'environnement pour le processus spécifié dans l'attribut processPath en les spécifiant dans un ou plusieurs éléments enfants environmentVariable d'un élément de collection environmentVariables sous l'élément aspNetCore. Les variables d'environnement définies dans cette section ont priorité sur les variables d'environnement système pour le processus.

Voici comment nous pouvons définir au moment de l'exécution:

public class Program
{
    public static void Main(string[] args)
    {
        Environment.SetEnvironmentVariable("ASPNETCORE_ENVIRONMENT", "Development");

        BuildWebHost(args).Run();
    }

    public static IWebHost BuildWebHost(string[] args) =>
        WebHost.CreateDefaultBuilder(args)
            .UseStartup<Startup>()
            .Build();
}

Avec la dernière version de dotnet cli (2.1.400 ou supérieure), vous pouvez simplement définir cette propriété msbuild $(EnvironmentName) et les outils de publication se chargeront d'ajouter ASPNETCORE_ENVIRONMENT au web.config avec le nom de l'environnement.

De plus, la prise en charge de XDT est disponible à partir de la version 2.2.100-preview1.

Exemple: https://github.com/vijayrkn/webconfigtransform/blob/master/README.md

1. Créez vos fichiers appsettings. *. Json. (Exemples: appsettings.Development.json, appsettings.Staging.json, appsettings.Production.json)

2. Ajoutez vos variables à ces fichiers.

3. Créez un profil de publication distinct pour chaque environnement, comme vous le feriez normalement.

4. Ouvrez PublishProfiles / Development.pubxml (le nom sera basé sur ce que vous avez nommé le profil de publication).

5. Ajoutez simplement une balise au PublishProfile pour définir le EnvironmentName variable , la convention de dénomination de fichier appsettings. *. Json s'occupe du reste.

    <PropertyGroup>
      <EnvironmentName>Development</EnvironmentName>
    </PropertyGroup>

Référence: https://docs.microsoft.com/en-us/aspnet/core/host-and-deploy/visual-studio-publish-profiles?view=aspnetcore-3.1

Reportez-vous à la section «Définir l'environnement».

Cette variable peut être enregistrée dans json. Par exemple envsettings.json avec le contenu ci-dessous

  {
   // Possible string values reported below. When empty it use ENV variable value or 
     // Visual Studio setting.
     // - Production
     // - Staging
     // - Test
     // - Development

   "ASPNETCORE_ENVIRONMENT": "Development"
  }

Modifiez ultérieurement votre programme.cs comme ci-dessous

  public class Program
  {
    public static IConfiguration Configuration { get; set; }
    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 environmentValue = envSettings["ASPNETCORE_ENVIRONMENT"].ToString();

        var builder = new ConfigurationBuilder()
               .SetBasePath(Directory.GetCurrentDirectory())
               .AddJsonFile("appsettings.json");

        Configuration = builder.Build();
          var webHostBuilder = new WebHostBuilder()
            .UseKestrel()
            .CaptureStartupErrors(true)
            .UseContentRoot(currentDirectoryPath)
            .UseIISIntegration()
            .UseStartup<Startup>();

        // If none is set it use Operative System hosting enviroment
        if (!string.IsNullOrWhiteSpace(environmentValue))
        {
            webHostBuilder.UseEnvironment(environmentValue);
        }

        var host = webHostBuilder.Build();

        host.Run();
     }
 }

De cette façon, il sera toujours inclus dans la publication et vous pouvez modifier la valeur requise en fonction de l'environnement dans lequel le site Web est hébergé. Cette méthode peut également être utilisée dans l'application console car les modifications sont dans Program.cs

J'ai trouvé que cela fonctionnait pour moi en définissant cette variable directement sur Azure Platorm (si vous l'utilisez). Sélectionnez simplement votre application Web -> configuration -> paramètres de l'application et ajoutez la variable et sa valeur, puis appuyez sur le bouton Enregistrer.

Une autre option que nous utilisons dans nos projets afin de pouvoir définir l'environnement par site est d'ajouter un fichier Parameters.xml au projet avec le contenu suivant:

<parameters>
      <parameter name="IIS Web Application Name" defaultValue="MyApp" tags="IisApp" />    
      <parameter name="Environment" description="Environment" tags="">
        <parameterEntry kind="XmlFile" scope="Web.config"  match="/configuration/location/system.webServer/aspNetCore/environmentVariables/environmentVariable[@name='ASPNETCORE_ENVIRONMENT']/@value" />
      </parameter>    
</parameters>

L'action de génération de ce fichier est Content et l'action de copie est Copy If Newer , elle fera donc partie du package à déployer.

Ensuite, pour déployer le package et définir l'environnement, dans la version, sous la tâche "WinRM - Déploiement d'applications Web IIS" (cela fonctionne aussi bien lorsque vous utilisez la tâche "Déploiement d'applications Web IIS"), nous définissons des arguments supplémentaires pour msdeploy :

-setParam:kind=ProviderPath,scope=contentPath,value="MySite" -setParam:name="Environment",value="Stage"

De cette façon, nous pouvons avoir plusieurs versions, toutes utilisant le même artefact, mais déployées dans des environnements différents.

Je sais que c'est un ancien article, mais j'ai pensé que je jetterais ma solution simple dans le mélange puisque personne ne l'a suggérée.

J'utilise le répertoire actuel pour déterminer l'environnement actuel, puis je retourne la chaîne de connexion et la variable d'environnement. Cela fonctionne très bien tant que vous avez une convention de dénomination pour les dossiers de votre site telle que test / beta / sandbox.

    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        var dir = Environment.CurrentDirectory;
        string connectionString;

        if (dir.Contains("test", StringComparison.OrdinalIgnoreCase))
        {
            connectionString = new ConnectionStringBuilder(server: "xxx", database: "xxx").ConnectionString;
            Environment.SetEnvironmentVariable("ASPNETCORE_ENVIRONMENT", "Development");
        }
        else
        {
            connectionString = new ConnectionStringBuilder(server: "xxx", database: "xxx").ConnectionString;
            Environment.SetEnvironmentVariable("ASPNETCORE_ENVIRONMENT", "Production");
        }

        optionsBuilder.UseSqlServer(connectionString);
        optionsBuilder.UseLazyLoadingProxies();
        optionsBuilder.EnableSensitiveDataLogging();
    }