¿Cómo configurar ASPNETCORE_ENVIRONMENT para que se considere la publicación de una aplicación principal de asp.net?

cuando publico mi aplicación web principal asp.net en mi sistema de archivos local, siempre toma la variable production-config y ASPNETCORE_ENVIRONMENT con el valor = "Production".

¿Cómo y dónde tengo que establecer el valor de la variable ASPNETCORE_ENVIRONMENT para que se considere no solo para la depuración, sino también para la publicación ? Ya probé las siguientes opciones sin éxito:

• en la configuración de Windows
• en archivo .pubxml
• en launchSettings.json
• en project.json

Además de las opciones mencionadas anteriormente, hay un par de otras soluciones.

1. Modificar el archivo de proyecto (.CsProj).

MSBuild admite la EnvironmentNamepropiedad, que puede ayudar a establecer la variable de entorno correcta según el entorno que desea implementar. El nombre del entorno se agregaría en web.config durante la fase de publicación.

Simplemente abra el archivo del proyecto (* .csProj) y agregue el siguiente XML.

<!-- 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>

El código anterior agregaría el nombre del entorno como Developmentpara la configuración de depuración o si no se especifica ninguna configuración. Para cualquier otra configuración, el nombre del entorno estaría Productionen el archivo web.config generado. Más detalles aquí

2. Agregar la propiedad EnvironmentName en los perfiles de publicación.

También podemos agregar la <EnvironmentName>propiedad en el perfil de publicación. Abra el archivo de perfil de publicación que se encuentra en. Properties/PublishProfiles/{profilename.pubxml}Esto establecerá el nombre del entorno en web.config cuando se publique el proyecto. Más detalles aquí

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

3. Opciones de la línea de comandos con dotnet publish

Además, podemos pasar la propiedad EnvironmentNamecomo una opción de línea de comando al dotnet publishcomando. El siguiente comando incluiría la variable de entorno como Developmenten el archivo web.config.

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

Opción 1:

Para configurar la variable de entorno ASPNETCORE_ENVIRONMENT en Windows,

Línea de comando - setx ASPNETCORE_ENVIRONMENT "Development"

Potencia Shell - $Env:ASPNETCORE_ENVIRONMENT = "Development"

Para otros sistemas operativos, consulte esto: https://docs.microsoft.com/en-us/aspnet/core/fundamentals/environments

Opcion 2:

Si desea configurar ASPNETCORE_ENVIRONMENT usando web.config, agregue aspNetCoreasí:

<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>

Una forma sencilla de configurarlo en Visual Studio IDE.

Proyecto> Propiedades> Depurar> Variables de entorno

Debe seguir las instrucciones proporcionadas en la documentación , utilizando la extensión 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>

Tenga en cuenta que también puede establecer otras variables de entorno.

El módulo ASP.NET Core le permite especificar variables de entorno para el proceso especificado en el atributo processPath al especificarlas en uno o más elementos secundarios environmentVariable de un elemento de colección environmentVariables en el elemento aspNetCore. Las variables de entorno establecidas en esta sección tienen prioridad sobre las variables de entorno del sistema para el proceso.

Así es como podemos configurar en tiempo de ejecución:

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();
}

Con la última versión de dotnet cli (2.1.400 o superior), puede configurar esta propiedad msbuild $(EnvironmentName)y las herramientas de publicación se encargarán de agregar ASPNETCORE_ENVIRONMENT al web.config con el nombre del entorno.

Además, la compatibilidad con XDT está disponible a partir de 2.2.100-preview1.

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

1. Cree sus archivos appsettings. *. Json. (Ejemplos: appsettings.Development.json, appsettings.Staging.json, appsettings.Production.json)

2. Agregue sus variables a esos archivos.

3. Cree un perfil de publicación independiente para cada entorno, como lo haría normalmente.

4. Abra PublishProfiles / Development.pubxml (la denominación se basará en el nombre del perfil de publicación).

5. Simplemente agregue una etiqueta al PublishProfile para establecer la variable EnvironmentName , la convención de nomenclatura de archivos appsettings. *. Json hace el resto.

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

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

Consulte la sección "Establecer el entorno".

Esta variable se puede guardar en json. Por ejemplo envsettings.json con el contenido de la siguiente manera

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

   "ASPNETCORE_ENVIRONMENT": "Development"
  }

Más tarde modifique su program.cs como se muestra a continuación

  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 esta manera, siempre se incluirá en la publicación y puede cambiar al valor requerido de acuerdo con el entorno donde se aloja el sitio web. Este método también se puede utilizar en la aplicación de consola, ya que los cambios están en Program.cs

Lo encontré funcionando para mí estableciendo esta variable directamente en la plataforma de Azure (si la usa). Simplemente seleccione su aplicación web -> configuración -> configuración de la aplicación y agregue la variable y su valor, luego presione el botón Guardar.

Otra opción que usamos en nuestros proyectos para poder configurar el entorno por sitio es agregar un archivo Parameters.xml al proyecto con el siguiente contenido:

<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>

La acción de compilación para este archivo es Contenido y la acción de copia es Copiar si es más reciente, por lo que será parte del paquete para implementar.

Luego, para implementar el paquete y configurar el entorno, en la versión, bajo la tarea "WinRM - Implementación de aplicaciones web IIS" (funciona igual de bien cuando se usa la tarea "Implementación de aplicaciones web IIS"), establecemos argumentos adicionales para msdeploy :

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

De esta manera podemos tener múltiples lanzamientos, todos usando el mismo artefacto, pero implementados como entornos diferentes.

Sé que esta es una publicación antigua, sin embargo, pensé en lanzar mi solución simple a la mezcla, ya que nadie la ha sugerido.

Utilizo el directorio actual para determinar el entorno actual y luego volteo la cadena de conexión y la variable de entorno. Esto funciona muy bien siempre que tenga una convención de nomenclatura para las carpetas de su sitio, como 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();
    }