Používání více prostředí v ASP.NET Core

Článek
05/13/2021
9 min ke čtení

ASP.NET Core konfiguruje chování aplikace na základě běhového prostředí pomocí proměnné prostředí.

Zobrazit nebo stáhnout ukázkový kód (Jak stáhnout)

Prostředí

Pro určení běhového prostředí ASP.NET Core čtení z následujících proměnných prostředí:

DOTNET_ENVIRONMENT
ASPNETCORE_ENVIRONMENTKdy ConfigureWebHostDefaults je volána metoda. Výchozí ASP.NET Core volání šablon webové aplikace ConfigureWebHostDefaults . ASPNETCORE_ENVIRONMENTHodnota Přepisuje DOTNET_ENVIRONMENT .

IHostEnvironment.EnvironmentNamelze nastavit na libovolnou hodnotu, ale následující hodnoty jsou poskytovány rozhraním:

Development: launchSettings.jsv sadě souborů na ASPNETCORE_ENVIRONMENT Development místním počítači.
Staging
Production: Výchozí nastavení DOTNET_ENVIRONMENT , pokud a nebylo ASPNETCORE_ENVIRONMENT nastaveno.

Následující kód:

Volá UseDeveloperExceptionPage , pokud ASPNETCORE_ENVIRONMENT je nastaven na Development .
Volá UseExceptionHandler , pokud je hodnota ASPNETCORE_ENVIRONMENT nastavena na Staging , Production nebo Staging_2 .
Vloží IWebHostEnvironment do Startup.Configure . Tento přístup je užitečný, když aplikace vyžaduje úpravu jenom Startup.Configure pro několik prostředí s minimálními rozdíly v kódu na prostředí.
Se podobá kódu generovanému šablonami ASP.NET Core.

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    if (env.IsDevelopment())
    {
        app.UseDeveloperExceptionPage();
    }

    if (env.IsProduction() || env.IsStaging() || env.IsEnvironment("Staging_2"))
    {
        app.UseExceptionHandler("/Error");
    }

    app.UseHttpsRedirection();
    app.UseStaticFiles();

    app.UseRouting();

    app.UseAuthorization();

    app.UseEndpoints(endpoints =>
    {
        endpoints.MapRazorPages();
    });
}

Pomocná značka prostředí používá hodnotu IHostEnvironment. Environment pro zahrnutí nebo vyloučení značek v elementu:

<environment include="Development">
    <div>The effective tag is: &lt;environment include="Development"&gt;</div>
</environment>
<environment exclude="Development">
    <div>The effective tag is: &lt;environment exclude="Development"&gt;</div>
</environment>
<environment include="Staging,Development,Staging_2">
    <div>
        The effective tag is:
        &lt;environment include="Staging,Development,Staging_2"&gt;
    </div>
</environment>

Stránka about z ukázkového kódu obsahuje předchozí kód a zobrazuje hodnotu IWebHostEnvironment.EnvironmentName .

V systému Windows a macOS se v proměnných a hodnotách prostředí nerozlišují velká a malá písmena. Ve výchozím nastavení se v proměnných a hodnotách prostředí Linux rozlišují velká a malá písmena .

Vytvořit EnvironmentsSample

Vzorový kód použitý v tomto dokumentu je založen na Razor projektu stránky s názvem EnvironmentsSample.

Následující kód vytvoří a spustí webovou aplikaci s názvem EnvironmentsSample:

dotnet new webapp -o EnvironmentsSample
cd EnvironmentsSample
dotnet run --verbosity normal

Po spuštění aplikace se zobrazí některé z následujících výstupů:

Using launch settings from c:\tmp\EnvironmentsSample\Properties\launchSettings.json
info: Microsoft.Hosting.Lifetime[0]
      Now listening on: https://localhost:5001
info: Microsoft.Hosting.Lifetime[0]
      Application started. Press Ctrl+C to shut down.
info: Microsoft.Hosting.Lifetime[0]
      Hosting environment: Development
info: Microsoft.Hosting.Lifetime[0]
      Content root path: c:\tmp\EnvironmentsSample

Vývoj a launchSettings.jsna

Vývojové prostředí může povolit funkce, které by se neměly zveřejnit v produkčním prostředí. Například šablony ASP.NET Core umožňují stránku s výjimkou vývojáře ve vývojovém prostředí.

Prostředí pro vývoj místních počítačů lze nastavit v Properties\launchSettings.jsv souboru projektu. Hodnoty prostředí nastavené v launchSettings.jspři přepisování hodnot nastavených v prostředí systému.

launchSettings.jsv souboru:

Se používá pouze v místním vývojovém počítači.
Není nasazen.
obsahuje nastavení profilu.

Následující JSON zobrazuje launchSettings.jsv souboru pro ASP.NET Core webový projekt s názvem EnvironmentsSample vytvořený v aplikaci Visual Studio nebo dotnet new :

{
  "iisSettings": {
    "windowsAuthentication": false, 
    "anonymousAuthentication": true, 
    "iisExpress": {
      "applicationUrl": "http://localhost:64645",
      "sslPort": 44366
    }
  },
  "profiles": {
    "IIS Express": {
      "commandName": "IISExpress",
      "launchBrowser": true,
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development"
      }
    },
    "EnvironmentsSample": {
      "commandName": "Project",
      "launchBrowser": true,
      "applicationUrl": "https://localhost:5001;http://localhost:5000",
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development"
      }
    }
  }
}

Předchozí kód obsahuje dva profily:

IIS Express: Výchozí profil, který se používá při spuštění aplikace ze sady Visual Studio. "commandName"Klíč má hodnotu "IISExpress" , proto je IISExpress webovým serverem. Můžete nastavit profil spuštění na projekt nebo jakýkoli jiný profil, který je součástí. Například na následujícím obrázku vyberte název projektu, který spustí webový server Kestrel.
EnvironmentsSample: Název profilu je název projektu. Tento profil se ve výchozím nastavení používá při spouštění aplikace pomocí dotnet run . "commandName"Klíč má hodnotu "Project" , proto je spuštěn webový server Kestrel .

Hodnota commandName může určovat webový server, který se má spustit. commandNamemůže to být jedna z následujících:

IISExpress: Spustí IIS Express.
IIS: Nebyl spuštěn žádný webový server. Očekává se, že služba IIS bude k dispozici.
Project: Spustí Kestrel.

Karta ladění vlastností projektu sady Visual Studio poskytuje grafické uživatelské rozhraní pro úpravu launchSettings.jsv souboru. Změny provedené v profilech projektu se neprojeví, dokud se webový server nerestartuje. Kestrel se musí restartovat, aby bylo možné zjistit změny provedené ve svém prostředí.

Vlastnosti projektu nastavení proměnných prostředí

Následující launchSettings.js souboru obsahuje několik profilů:

{
  "iisSettings": {
    "windowsAuthentication": false, 
    "anonymousAuthentication": true, 
    "iisExpress": {
      "applicationUrl": "http://localhost:64645",
      "sslPort": 44366
    }
  },
  "profiles": {
    "IIS Express": {
      "commandName": "IISExpress",
      "launchBrowser": true,
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development"
      }
    },
    "IISX-Production": {
      "commandName": "IISExpress",
      "launchBrowser": true,
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Production"
      }
    },
    "IISX-Staging": {
      "commandName": "IISExpress",
      "launchBrowser": true,
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Staging",
        "ASPNETCORE_DETAILEDERRORS": "1",
        "ASPNETCORE_SHUTDOWNTIMEOUTSECONDS": "3"
      }
    },
    "EnvironmentsSample": {
      "commandName": "Project",
      "launchBrowser": true,
      "applicationUrl": "https://localhost:5001;http://localhost:5000",
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development"
      }
    },
    "KestrelStaging": {
      "commandName": "Project",
      "launchBrowser": true,
      "applicationUrl": "https://localhost:5001;http://localhost:5000",
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Staging"
      }
    }
  }
}

Můžete vybrat profily:

Z uživatelského rozhraní sady Visual Studio.
Pomocí dotnet run příkazu v příkazovém prostředí s --launch-profile možností nastavenou na název profilu. Tento přístup podporuje jenom Kestrel profily.
```
dotnet run --launch-profile "SampleApp"
```

Upozornění

launchSettings.js by neměl ukládat tajné klíče. Nástroj Správce tajných klíčů je možné použít k ukládání tajných kódů pro místní vývoj.

Při použití Visual Studio Codelze proměnné prostředí nastavit v souboru . VSCode/launch.js . Následující příklad nastaví několik hodnot konfigurace hostitele proměnné prostředí:

{
    "version": "0.2.0",
    "configurations": [
        {
            "name": ".NET Core Launch (web)",
            "type": "coreclr",
            // Configuration ommitted for brevity.
            "env": {
                "ASPNETCORE_ENVIRONMENT": "Development",
                "ASPNETCORE_URLS": "https://localhost:5001",
                "ASPNETCORE_DETAILEDERRORS": "1",
                "ASPNETCORE_SHUTDOWNTIMEOUTSECONDS": "3"
            },
            // Configuration ommitted for brevity.

Soubor . VSCode/launch.js je používán pouze Visual Studio Code.

Produkce

Provozní prostředí by mělo být nakonfigurované tak, aby maximalizovalo zabezpečení, výkona odolnost aplikací. Mezi běžná nastavení, která se liší od vývoje, patří:

Ukládání do mezipaměti.
Prostředky na straně klienta jsou seskupené, minifikovaného a potenciálně poskytované z CDN.
Chybové stránky diagnostiky jsou zakázané.
Jsou povoleny popisné chybové stránky.
Protokolování a sledování výroby je povolené. Například pomocí Application Insights.

Nastavení prostředí

Je často užitečné nastavit konkrétní prostředí pro testování pomocí proměnné prostředí nebo nastavení platformy. Pokud prostředí není nastavené, nastaví se jako výchozí Production , což zakáže většinu funkcí ladění. Metoda nastavení prostředí závisí na operačním systému.

Po sestavení hostitele určuje poslední nastavení prostředí načtené aplikací prostředí aplikace. Prostředí aplikace se nedá změnit, když je aplikace spuštěná.

Stránka about z ukázkového kódu zobrazí hodnotu IWebHostEnvironment.EnvironmentName .

Azure App Service

Pokud chcete nastavit prostředí v Azure App Service, proveďte následující kroky:

Vyberte aplikaci z okna App Services .
Ve skupině Nastavení vyberte okno Konfigurace .
Na kartě nastavení aplikace vyberte možnost nové nastavení aplikace.
V okně Přidat nebo upravit nastavení aplikace zadejte ASPNETCORE_ENVIRONMENT název. V poli hodnotazadejte prostředí (například Staging ).
Zaškrtněte políčko nastavení slotu nasazení , pokud chcete, aby nastavení prostředí zůstalo v aktuální pozici, když jsou sloty nasazení prohozeny. Další informace najdete v tématu Nastavení přípravného prostředí v Azure App Service v dokumentaci k Azure.
Výběrem OK zavřete okno Přidat/upravit nastavení aplikace .
V horní části okna Konfigurace vyberte Uložit .

Azure App Service automaticky restartuje aplikaci po přidání, změně nebo odstranění nastavení aplikace v Azure Portal.

Windows

Hodnoty prostředí v launchSettings.jspři přepisování hodnot nastavených v prostředí systému.

K nastavení ASPNETCORE_ENVIRONMENT pro aktuální relaci při zahájení aplikace pomocí spuštění dotnetse použijí následující příkazy:

Příkazový řádek

set ASPNETCORE_ENVIRONMENT=Staging
dotnet run --no-launch-profile

PowerShell

$Env:ASPNETCORE_ENVIRONMENT = "Staging"
dotnet run --no-launch-profile

Předchozí příkaz nastaví ASPNETCORE_ENVIRONMENT pouze procesy spouštěné z tohoto příkazového okna.

K nastavení hodnoty globálně ve Windows použijte některý z následujících přístupů:

Otevřete ovládací panel > System > Upřesnit systémová nastavení a přidejte nebo upravte ASPNETCORE_ENVIRONMENT hodnotu:
Otevřete příkazový řádek pro správu a použijte setx příkaz nebo otevřete příkazový řádek prostředí PowerShell pro správu a použijte příkaz [Environment]::SetEnvironmentVariable :

Příkazový řádek
```
setx ASPNETCORE_ENVIRONMENT Staging /M
```
/MPřepínač označuje nastavení proměnné prostředí na úrovni systému. Pokud /M přepínač není použit, je pro uživatelský účet nastavena proměnná prostředí.

PowerShell
```
[Environment]::SetEnvironmentVariable("ASPNETCORE_ENVIRONMENT", "Staging", "Machine")
```
MachineHodnota možnosti určuje nastavení proměnné prostředí na úrovni systému. Pokud je hodnota možnosti změněna na User , je pro uživatelský účet nastavena proměnná prostředí.

Pokud ASPNETCORE_ENVIRONMENT je proměnná prostředí nastavena globálně, projeví se dotnet run v jakémkoli příkazovém okně otevřeném po nastavení hodnoty. Hodnoty prostředí v launchSettings.jspři přepisování hodnot nastavených v prostředí systému.

web.config

Chcete-li nastavit ASPNETCORE_ENVIRONMENT proměnnou prostředí pomocí web.config, přečtěte si část nastavení proměnných prostředí v tématu Modul ASP.NET Core .

Projektový soubor nebo profil publikování

Pro nasazení služby Windows IIS: Zahrňte <EnvironmentName> vlastnost do profilu publikování (. pubxml) nebo souboru projektu. Tento přístup nastaví prostředí v web.config při publikování projektu:

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

Pro fond aplikací služby IIS

Pokud chcete nastavit ASPNETCORE_ENVIRONMENT proměnnou prostředí pro aplikaci spuštěnou v izolovaném fondu aplikací (podporovaném ve službě IIS 10,0 nebo novější), přečtěte si část AppCmd.exe příkazu v tématu < environmentVariables > Variables (prostředí ). Když ASPNETCORE_ENVIRONMENT je pro fond aplikací nastavená proměnná prostředí, přepíše její hodnota nastavení na úrovni systému.

Při hostování aplikace ve službě IIS a přidání nebo změny ASPNETCORE_ENVIRONMENT proměnné prostředí použijte libovolný z následujících přístupů, aby byla nová hodnota vyzvednuta aplikacemi:

Spustí net stop was /y a pak net start w3svc z příkazového řádku.
Restartujte server.

macOS

Nastavení aktuálního prostředí pro macOS se dá při spuštění aplikace provést na řádku:

ASPNETCORE_ENVIRONMENT=Staging dotnet run

Případně můžete nastavit prostředí pomocí export před spuštěním aplikace:

export ASPNETCORE_ENVIRONMENT=Staging

Proměnné prostředí na úrovni počítače jsou nastaveny v souboru . bashrc nebo . bash_profile . Upravte soubor pomocí libovolného textového editoru. Přidejte následující příkaz:

export ASPNETCORE_ENVIRONMENT=Staging

Linux

U distribucí systému Linux použijte export příkaz na příkazovém řádku pro nastavení proměnné založené na relaci a soubor bash_profile pro nastavení prostředí na úrovni počítače.

Nastavení prostředí v kódu

Zavolejte UseEnvironment při sestavování hostitele. Viz třída Obecný hostitel .NET v ASP.NET Core.

Konfigurace podle prostředí

Pokud chcete načíst konfiguraci podle prostředí, přečtěte si téma Konfigurace v ASP.NET Core .

Třída a metody spouštění založené na prostředí

Vložení IWebHostEnvironment do spouštěcí třídy

Vložit IWebHostEnvironment do Startup konstruktoru. Tento přístup je užitečný, když aplikace vyžaduje konfiguraci Startup jenom pro několik prostředí s minimálními rozdíly v kódu pro každé prostředí.

V následujícím příkladu:

Prostředí se uchovává v _env poli.
_envse používá v ConfigureServices Configure systémech a k aplikování konfigurace spuštění na základě prostředí aplikace.

public class Startup
{
    public Startup(IConfiguration configuration, IWebHostEnvironment env)
    {
        Configuration = configuration;
        _env = env;
    }

    public IConfiguration Configuration { get; }
    private readonly IWebHostEnvironment _env;

    public void ConfigureServices(IServiceCollection services)
    {
        if (_env.IsDevelopment())
        {
            Console.WriteLine(_env.EnvironmentName);
        }
        else if (_env.IsStaging())
        {
            Console.WriteLine(_env.EnvironmentName);
        }
        else
        {
            Console.WriteLine("Not dev or staging");
        }

        services.AddRazorPages();
    }

    public void Configure(IApplicationBuilder app)
    {
        if (_env.IsDevelopment())
        {
            app.UseDeveloperExceptionPage();
        }
        else
        {
            app.UseExceptionHandler("/Error");
            app.UseHsts();
        }

        app.UseHttpsRedirection();
        app.UseStaticFiles();

        app.UseRouting();

        app.UseAuthorization();

        app.UseEndpoints(endpoints =>
        {
            endpoints.MapRazorPages();
        });
    }
}

Konvence třídy spouštění

Při spuštění aplikace ASP.NET Core spustí spouštěcí třída aplikaci. Aplikace může definovat více Startup tříd pro různá prostředí. Příslušná Startup Třída je vybrána za běhu. Určuje prioritu třídy, jejíž přípona názvu odpovídá aktuálnímu prostředí. Pokud Startup{EnvironmentName} není nalezena shodná třída, Startup je použita třída. Tento přístup je užitečný, když aplikace vyžaduje konfiguraci spuštění pro několik prostředí s mnoha rozdíly v kódu pro každé prostředí. Typické aplikace nebudou tento přístup potřebovat.

Chcete-li implementovat třídy založené na prostředí Startup , vytvořte Startup{EnvironmentName} třídy a záložní Startup třídu:

public class StartupDevelopment
{
    public StartupDevelopment(IConfiguration configuration)
    {
        Configuration = configuration;
        Console.WriteLine(MethodBase.GetCurrentMethod().DeclaringType.Name);
    }

    public IConfiguration Configuration { get; }

    public void ConfigureServices(IServiceCollection services)
    {
        services.AddRazorPages();
    }

    public void Configure(IApplicationBuilder app)
    {
        app.UseDeveloperExceptionPage();

        app.UseHttpsRedirection();
        app.UseStaticFiles();

        app.UseRouting();

        app.UseAuthorization();

        app.UseEndpoints(endpoints =>
        {
            endpoints.MapRazorPages();
        });
    }
}

public class StartupProduction
{
    public StartupProduction(IConfiguration configuration)
    {
        Configuration = configuration;
        Console.WriteLine(MethodBase.GetCurrentMethod().DeclaringType.Name);
    }

    public IConfiguration Configuration { get; }

    public void ConfigureServices(IServiceCollection services)
    {
        services.AddRazorPages();
    }

    public void Configure(IApplicationBuilder app)
    {

        app.UseExceptionHandler("/Error");
        app.UseHsts();

        app.UseHttpsRedirection();
        app.UseStaticFiles();

        app.UseRouting();

        app.UseAuthorization();

        app.UseEndpoints(endpoints =>
        {
            endpoints.MapRazorPages();
        });
    }
}

public class Startup
{
    public Startup(IConfiguration configuration)
    {
        Configuration = configuration;
        Console.WriteLine(MethodBase.GetCurrentMethod().DeclaringType.Name);
    }

    public IConfiguration Configuration { get; }

    public void ConfigureServices(IServiceCollection services)
    {
        services.AddRazorPages();
    }

    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {
        if (env.IsDevelopment())
        {
            app.UseDeveloperExceptionPage();
        }
        else
        {
            app.UseExceptionHandler("/Error");
            app.UseHsts();
        }

        app.UseHttpsRedirection();
        app.UseStaticFiles();

        app.UseRouting();

        app.UseAuthorization();

        app.UseEndpoints(endpoints =>
        {
            endpoints.MapRazorPages();
        });
    }
}

Použijte přetížení UseStartup (IWebHostBuilder, String) , které přijímá název sestavení:

public class Program
{
    public static void Main(string[] args)
    {
        CreateHostBuilder(args).Build().Run();
    }

    public static IHostBuilder CreateHostBuilder(string[] args)
    {
        var assemblyName = typeof(Startup).GetTypeInfo().Assembly.FullName;

        return   Host.CreateDefaultBuilder(args)
            .ConfigureWebHostDefaults(webBuilder =>
            {
                webBuilder.UseStartup(assemblyName);
            });
    }
}

Konvence metody spuštění

Nakonfigurujte a ConfigureServiceste podporu pro konkrétní verze formuláře a prostředí Configure<EnvironmentName> Configure<EnvironmentName>Services . Tento přístup je užitečný, když aplikace vyžaduje konfiguraci spuštění pro několik prostředí s mnoha rozdíly v kódu na prostředí:

public class Startup
{
    private void StartupConfigureServices(IServiceCollection services)
    {
        services.AddRazorPages();
    }

    public void ConfigureDevelopmentServices(IServiceCollection services)
    {
        MyTrace.TraceMessage();
        StartupConfigureServices(services);
    }

    public void ConfigureStagingServices(IServiceCollection services)
    {
        MyTrace.TraceMessage();
        StartupConfigureServices(services);
    }

    public void ConfigureProductionServices(IServiceCollection services)
    {
        MyTrace.TraceMessage();
        StartupConfigureServices(services);
    }

    public void ConfigureServices(IServiceCollection services)
    {
        MyTrace.TraceMessage();
        StartupConfigureServices(services);
    }

    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {
        MyTrace.TraceMessage();

        if (env.IsDevelopment())
        {
            app.UseDeveloperExceptionPage();
        }
        else
        {
            app.UseExceptionHandler("/Error");
            app.UseHsts();
        }

        app.UseHttpsRedirection();
        app.UseStaticFiles();

        app.UseRouting();

        app.UseAuthorization();

        app.UseEndpoints(endpoints =>
        {
            endpoints.MapRazorPages();
        });
    }

    public void ConfigureStaging(IApplicationBuilder app, IWebHostEnvironment env)
    {
        MyTrace.TraceMessage();

        app.UseExceptionHandler("/Error");
        app.UseHsts();

        app.UseHttpsRedirection();
        app.UseStaticFiles();

        app.UseRouting();

        app.UseAuthorization();

        app.UseEndpoints(endpoints =>
        {
            endpoints.MapRazorPages();
        });
    }
}

public static class MyTrace
{
    public static void TraceMessage([CallerMemberName] string memberName = "")
    {
        Console.WriteLine($"Method: {memberName}");
    }
}

Další zdroje

Autor: Rick Anderson

ASP.NET Core konfiguruje chování aplikace na základě běhového prostředí pomocí proměnné prostředí.

Zobrazit nebo stáhnout ukázkový kód (Jak stáhnout)

Prostředí

ASP.NET Core přečte proměnnou prostředí ASPNETCORE_ENVIRONMENT při spuštění aplikace a uloží hodnotu do IHostingEnvironment. Environment. ASPNETCORE_ENVIRONMENTlze nastavit na libovolnou hodnotu, ale rozhraní poskytuje tři hodnoty:

public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
    if (env.IsDevelopment())
    {
        app.UseDeveloperExceptionPage();
    }

    if (env.IsProduction() || env.IsStaging() || env.IsEnvironment("Staging_2"))
    {
        app.UseExceptionHandler("/Error");
    }

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

Předcházející kód:

Volá UseDeveloperExceptionPage , pokud ASPNETCORE_ENVIRONMENT je nastaven na Development .
Volá UseExceptionHandler , pokud je hodnota ASPNETCORE_ENVIRONMENT nastavená na jednu z následujících hodnot:
- Staging
- Production
- Staging_2

Pomocná značka prostředí používá hodnotu IHostingEnvironment.EnvironmentName pro zahrnutí nebo vyloučení značek v elementu:

<environment include="Development">
    <div>The effective tag is: &lt;environment include="Development"&gt;</div>
</environment>
<environment exclude="Development">
    <div>The effective tag is: &lt;environment exclude="Development"&gt;</div>
</environment>
<environment include="Staging,Development,Staging_2">
    <div>
        The effective tag is:
        &lt;environment include="Staging,Development,Staging_2"&gt;
    </div>
</environment>

V systému Windows a macOS se v proměnných a hodnotách prostředí nerozlišují velká a malá písmena. Ve výchozím nastavení se v proměnných a hodnotách prostředí Linux rozlišují velká a malá písmena.

Vývoj

Následující JSON zobrazuje tři profily z launchSettings.jsv souboru:

{
  "iisSettings": {
    "windowsAuthentication": false,
    "anonymousAuthentication": true,
    "iisExpress": {
      "applicationUrl": "http://localhost:54339/",
      "sslPort": 0
    }
  },
  "profiles": {
    "IIS Express": {
      "commandName": "IISExpress",
      "launchBrowser": true,
      "environmentVariables": {
        "ASPNETCORE_My_Environment": "1",
        "ASPNETCORE_DETAILEDERRORS": "1",
        "ASPNETCORE_ENVIRONMENT": "Staging"
      }
    },
    "EnvironmentsSample": {
      "commandName": "Project",
      "launchBrowser": true,
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Staging"
      },
      "applicationUrl": "http://localhost:54340/"
    },
    "Kestrel Staging": {
      "commandName": "Project",
      "launchBrowser": true,
      "environmentVariables": {
        "ASPNETCORE_My_Environment": "1",
        "ASPNETCORE_DETAILEDERRORS": "1",
        "ASPNETCORE_ENVIRONMENT": "Staging"
      },
      "applicationUrl": "http://localhost:51997/"
    }
  }
}

Poznámka

applicationUrlVlastnost v launchSettings.jsv může určovat seznam adres URL serveru. Použijte středník mezi adresami URL v seznamu:

"EnvironmentsSample": {
   "commandName": "Project",
   "launchBrowser": true,
   "applicationUrl": "https://localhost:5001;http://localhost:5000",
   "environmentVariables": {
     "ASPNETCORE_ENVIRONMENT": "Development"
   }
}

Když se aplikace spustí pomocí příkazu dotnet, použije se první profil "commandName": "Project" . Hodnota commandName Určuje webový server, který se má spustit. commandNamemůže to být jedna z následujících:

IISExpress
IIS
Project(která spouští Kestrel)

Když se aplikace spustí s použitím příkazu dotnet:

launchSettings.jszapnuto je přečteno, pokud je k dispozici. environmentVariablesnastavení v launchSettings.jspři přepisu proměnných prostředí.
Zobrazí se hostující prostředí.

Následující výstup ukazuje aplikaci spuštěnou pomocí příkazu dotnet:

PS C:\Websites\EnvironmentsSample> dotnet run
Using launch settings from C:\Websites\EnvironmentsSample\Properties\launchSettings.json...
Hosting environment: Staging
Content root path: C:\Websites\EnvironmentsSample
Now listening on: http://localhost:54340
Application started. Press Ctrl+C to shut down.

Karta ladění vlastností projektu sady Visual Studio poskytuje grafické uživatelské rozhraní pro úpravu launchSettings.jsv souboru:

Vlastnosti projektu nastavení proměnných prostředí

Změny provedené v profilech projektu se neprojeví, dokud se webový server nerestartuje. Kestrel se musí restartovat, aby bylo možné zjistit změny provedené ve svém prostředí.

Upozornění

launchSettings.js by neměl ukládat tajné klíče. Nástroj Správce tajných klíčů je možné použít k ukládání tajných kódů pro místní vývoj.

Při použití Visual Studio Codelze proměnné prostředí nastavit v souboru . VSCode/launch.js . Následující příklad nastaví prostředí na Development :

{
   "version": "0.2.0",
   "configurations": [
        {
            "name": ".NET Core Launch (web)",

            ... additional VS Code configuration settings ...

            "env": {
                "ASPNETCORE_ENVIRONMENT": "Development"
            }
        }
    ]
}

A . VSCode/launch.js v souboru v projektu se při spouštění aplikace dotnet run stejným způsobem jako vlastnosti/launchSettings.jsnenačte. Při spouštění aplikace ve vývoji, která nemá launchSettings.jsv souboru, buď nastavte prostředí s proměnnou prostředí nebo argumentem příkazového řádku pro dotnet run příkaz.

Produkce

Provozní prostředí by mělo být nakonfigurované tak, aby maximalizovalo zabezpečení, výkon a odolnost aplikací. Mezi běžná nastavení, která se liší od vývoje, patří:

Vyrovnávací.
Prostředky na straně klienta jsou seskupené, minifikovaného a potenciálně poskytované z CDN.
Chybové stránky diagnostiky jsou zakázané.
Jsou povoleny popisné chybové stránky.
Protokolování a sledování výroby je povolené. Například Application Insights.

Nastavení prostředí

Po sestavení hostitele určuje poslední nastavení prostředí načtené aplikací prostředí aplikace. Prostředí aplikace se nedá změnit, když je aplikace spuštěná.

Nastavení proměnné prostředí nebo platformy

Azure App Service

Pokud chcete nastavit prostředí v Azure App Service, proveďte následující kroky:

Vyberte aplikaci z okna App Services .
Ve skupině Nastavení vyberte okno Konfigurace .
Na kartě nastavení aplikace vyberte možnost nové nastavení aplikace.
V okně Přidat nebo upravit nastavení aplikace zadejte ASPNETCORE_ENVIRONMENT název. V poli hodnotazadejte prostředí (například Staging ).
Zaškrtněte políčko nastavení slotu nasazení , pokud chcete, aby nastavení prostředí zůstalo v aktuální pozici, když jsou sloty nasazení prohozeny. Další informace najdete v tématu Nastavení přípravného prostředí v Azure App Service v dokumentaci k Azure.
Výběrem OK zavřete okno Přidat/upravit nastavení aplikace .
V horní části okna Konfigurace vyberte Uložit .

Azure App Service automaticky restartuje aplikaci po přidání, změně nebo odstranění nastavení aplikace (proměnná prostředí) v Azure Portal.

Windows

K nastavení ASPNETCORE_ENVIRONMENT pro aktuální relaci při zahájení aplikace pomocí spuštění dotnetse použijí následující příkazy:

Příkazový řádek

set ASPNETCORE_ENVIRONMENT=Development

PowerShell

$Env:ASPNETCORE_ENVIRONMENT = "Development"

Tyto příkazy se projeví pouze pro aktuální okno. Po zavření okna se ASPNETCORE_ENVIRONMENT nastavení vrátí k výchozímu nastavení nebo hodnotě počítače.

K nastavení hodnoty globálně ve Windows použijte některý z následujících přístupů:

Otevřete ovládací panel > System > Upřesnit systémová nastavení a přidejte nebo upravte ASPNETCORE_ENVIRONMENT hodnotu:
Otevřete příkazový řádek pro správu a použijte setx příkaz nebo otevřete příkazový řádek prostředí PowerShell pro správu a použijte příkaz [Environment]::SetEnvironmentVariable :

Příkazový řádek
```
setx ASPNETCORE_ENVIRONMENT Development /M
```
/MPřepínač označuje nastavení proměnné prostředí na úrovni systému. Pokud /M přepínač není použit, je pro uživatelský účet nastavena proměnná prostředí.

PowerShell
```
[Environment]::SetEnvironmentVariable("ASPNETCORE_ENVIRONMENT", "Development", "Machine")
```
MachineHodnota možnosti určuje nastavení proměnné prostředí na úrovni systému. Pokud je hodnota možnosti změněna na User , je pro uživatelský účet nastavena proměnná prostředí.

Pokud ASPNETCORE_ENVIRONMENT je proměnná prostředí nastavena globálně, projeví se dotnet run v jakémkoli příkazovém okně otevřeném po nastavení hodnoty.

web.config

Chcete-li nastavit ASPNETCORE_ENVIRONMENT proměnnou prostředí pomocí web.config, přečtěte si část nastavení proměnných prostředí v tématu Modul ASP.NET Core .

Projektový soubor nebo profil publikování

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

Pro fond aplikací služby IIS

Důležité

Spustí net stop was /y a pak net start w3svc z příkazového řádku.
Restartujte server.

macOS

Nastavení aktuálního prostředí pro macOS se dá při spuštění aplikace provést na řádku:

ASPNETCORE_ENVIRONMENT=Development dotnet run

Případně můžete nastavit prostředí pomocí export před spuštěním aplikace:

export ASPNETCORE_ENVIRONMENT=Development

Proměnné prostředí na úrovni počítače jsou nastaveny v souboru . bashrc nebo . bash_profile . Upravte soubor pomocí libovolného textového editoru. Přidejte následující příkaz:

export ASPNETCORE_ENVIRONMENT=Development

Linux

Nastavení prostředí v kódu

Zavolejte UseEnvironment při sestavování hostitele. Viz třída ASP.NET Core Webový hostitel.

Konfigurace podle prostředí

K načtení konfigurace podle prostředí doporučujeme:

soubory appSettings (appSettings. { Environment}. JSON. Viz třída Konfigurace v ASP.NET Core.
Proměnné prostředí (nastavené v každém systému, ve kterém je aplikace hostovaná). Viz ASP.NET Core Webový hostitel a Sejf ukládání tajných kódů aplikací ve vývoji v ASP.NET Core .
Správce tajných klíčů (jenom ve vývojovém prostředí). Viz třída Sejf ukládání tajných kódů aplikací ve vývoji v ASP.NET Core.

Třída a metody spouštění založené na prostředí

Vložení IHostingEnvironment do Startup.Configurovat

Vložit IHostingEnvironment do Startup.Configure . Tento přístup je užitečný, když aplikace vyžaduje jenom konfiguraci Startup.Configure jenom pro několik prostředí s minimálními rozdíly v kódu pro každé prostředí.

public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
    if (env.IsDevelopment())
    {
        // Development environment code
    }
    else
    {
        // Code for all other environments
    }
}

Vložení IHostingEnvironment do spouštěcí třídy

Vložení IHostingEnvironment do Startup konstruktoru a přiřazení služby k poli pro použití v rámci Startup třídy. Tento přístup je užitečný, když aplikace vyžaduje konfiguraci spouštění jenom pro několik prostředí s minimálními rozdíly v kódu pro každé prostředí.

V následujícím příkladu:

Prostředí se uchovává v _env poli.
_envse používá v ConfigureServices Configure systémech a k aplikování konfigurace spuštění na základě prostředí aplikace.

public class Startup
{
    private readonly IHostingEnvironment _env;

    public Startup(IHostingEnvironment env)
    {
        _env = env;
    }

    public void ConfigureServices(IServiceCollection services)
    {
        if (_env.IsDevelopment())
        {
            // Development environment code
        }
        else if (_env.IsStaging())
        {
            // Staging environment code
        }
        else
        {
            // Code for all other environments
        }
    }

    public void Configure(IApplicationBuilder app)
    {
        if (_env.IsDevelopment())
        {
            // Development environment code
        }
        else
        {
            // Code for all other environments
        }
    }
}

Konvence třídy spouštění

Při spuštění aplikace ASP.NET Core spustí spouštěcí třída aplikaci. Aplikace může definovat samostatné Startup třídy pro různá prostředí (například StartupDevelopment ). Příslušná Startup Třída je vybrána za běhu. Určuje prioritu třídy, jejíž přípona názvu odpovídá aktuálnímu prostředí. Pokud Startup{EnvironmentName} není nalezena shodná třída, Startup je použita třída. Tento přístup je užitečný, když aplikace vyžaduje konfiguraci spuštění pro několik prostředí s mnoha rozdíly v kódu pro každé prostředí.

Chcete-li implementovat třídy založené na prostředí Startup , vytvořte Startup{EnvironmentName} třídu pro každé používané prostředí a záložní Startup třídu:

// Startup class to use in the Development environment
public class StartupDevelopment
{
    public void ConfigureServices(IServiceCollection services)
    {
    }

    public void Configure(IApplicationBuilder app, IHostingEnvironment env)
    {
    }
}

// Startup class to use in the Production environment
public class StartupProduction
{
    public void ConfigureServices(IServiceCollection services)
    {
    }

    public void Configure(IApplicationBuilder app, IHostingEnvironment env)
    {
    }
}

// Fallback Startup class
// Selected if the environment doesn't match a Startup{EnvironmentName} class
public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
    }

    public void Configure(IApplicationBuilder app, IHostingEnvironment env)
    {
    }
}

Použijte přetížení UseStartup (IWebHostBuilder, String) , které přijímá název sestavení:

public static void Main(string[] args)
{
    CreateWebHostBuilder(args).Build().Run();
}

public static IWebHostBuilder CreateWebHostBuilder(string[] args)
{
    var assemblyName = typeof(Startup).GetTypeInfo().Assembly.FullName;

    return WebHost.CreateDefaultBuilder(args)
        .UseStartup(assemblyName);
}

Konvence metody spuštění

public class Startup
{
    public Startup(IConfiguration configuration)
    {
        Configuration = configuration;
    }

    public IConfiguration Configuration { get; }

    public void ConfigureServices(IServiceCollection services)
    {
        StartupConfigureServices(services);
    }

    public void ConfigureStagingServices(IServiceCollection services)
    {
        StartupConfigureServices(services);
    }

    private void StartupConfigureServices(IServiceCollection services)
    {
        services.AddMvc()
            .SetCompatibilityVersion(CompatibilityVersion.Version_2_2);
    }

    public void Configure(IApplicationBuilder app, IHostingEnvironment env)
    {
        if (env.IsDevelopment())
        {
            app.UseDeveloperExceptionPage();
        }

        if (env.IsProduction() || env.IsStaging() || env.IsEnvironment("Staging_2"))
        {
            app.UseExceptionHandler("/Error");
        }

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

    public void ConfigureStaging(IApplicationBuilder app, IHostingEnvironment env)
    {
        if (!env.IsStaging())
        {
            throw new Exception("Not staging.");
        }

        app.UseExceptionHandler("/Error");
        app.UseStaticFiles();
        app.UseMvc();
    }
}

Používání více prostředí v ASP.NET Core

Ohodnoťte vaše zkušenosti

Prostředí

Vytvořit EnvironmentsSample

Vývoj a launchSettings.jsna

Produkce

Nastavení prostředí

Azure App Service

Windows

macOS

Linux

Nastavení prostředí v kódu

Konfigurace podle prostředí

Třída a metody spouštění založené na prostředí

Vložení IWebHostEnvironment do spouštěcí třídy

Konvence třídy spouštění

Konvence metody spuštění

Další zdroje

Prostředí

Vývoj

Produkce

Nastavení prostředí

Nastavení proměnné prostředí nebo platformy

Azure App Service

Windows

macOS

Linux

Nastavení prostředí v kódu

Konfigurace podle prostředí

Třída a metody spouštění založené na prostředí

Vložení IHostingEnvironment do Startup.Configurovat

Vložení IHostingEnvironment do spouštěcí třídy

Konvence třídy spouštění

Konvence metody spuštění

Další materiály