wake-up-neo.com

Wie publizieren Sie umgebungsspezifische Apps in der .Net Core App?

Ich habe 3 umgebungsspezifische appsettings-Dateien in meiner .NET-Kernanwendung

 enter image description here

in project.json habe ich publishOptions so eingerichtet. (auf Vorschlag hier )

"publishOptions": {
    "include": [
      "wwwroot",      
      "appsettings.development.json",
      "appsettings.staging.json",
      "appsettings.production.json",
      "web.config"
    ]
  },

Ich habe 3 entsprechende Startklassen, die entsprechend der Umgebung appsetings verwenden

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

Wenn ich jedoch die Anwendung veröffentliche, werden alle 3 appsettings-Dateien in allen Umgebungen beendet. Wie kann ich eine umgebungsspezifische App-Datei veröffentlichen?

17
LP13

Eine Möglichkeit wäre, vorveröffentlichte oder nachveröffentlichte Skripts/Befehle auszuführen, z. B. durch Ausführen einer gulp-Task, die dotnet publish-iis ausführt (alternativ verwenden Sie eine Task im prepublish -Abschnitt von scripts, um die Dateien vor der Veröffentlichung zu kopieren.

Fügen Sie dies zu Ihrem Projekt hinzu.json:

"scripts": {
  "postpublish": [ "gulp cleanconfig", "dotnet publish-iis --publish-folder %publish:OutputPath% --framework %publish:FullTargetFramework%" ]
}

Sie können hier auch einen Cmd- oder Shell-Befehl ausführen. Aber eigentlich sollte es keine Gründe dafür geben, warum Sie dies eigentlich tun möchten. Versenden Sie einfach alle 3 appconfig-Dateien, da Sie beispielsweise den Azure App Service verwenden können, um den Modus in Abhängigkeit von den Umgebungsvariablen umzuschalten Azure Portal und beim Veröffentlichen werden die Bereitstellungs- und Produktionsslots lediglich ausgetauscht, die Umgebungsvariablen bleiben jedoch erhalten.

Sie sollten jedoch keine Geheimnisse in der Datei appsettings.json speichern (was vermutlich davon ausgeht, dass Sie dies tun und warum Sie die Dateien entfernen möchten). Verwenden Sie stattdessen "Benutzergeheimnisse" für Entwicklungs- und Umgebungsvariablen, um Verbindungszeichenfolgen usw. für die Produktion festzulegen. Funktioniert wie ein Zauber, besonders mit Azure App Services und Docker-Containern.

3
Tseng

Ich musste kürzlich auch dafür eine Lösung finden und habe einige Einstellungen in die Datei .csproj Und eine geringfügige Änderung in Program.cs Eingefügt.

<Project Sdk="Microsoft.NET.Sdk.Web">
    <!-- ... -->
    <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|AnyCPU'">
        <DebugSymbols>true</DebugSymbols>
        <DebugType>full</DebugType>
        <DefineConstants>DEBUG;TRACE</DefineConstants>
        <EnvironmentName>Development</EnvironmentName>
    </PropertyGroup>
    <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|AnyCPU'">
        <DebugType>pdbonly</DebugType>
        <Optimize>true</Optimize>
        <EnvironmentName>Production</EnvironmentName>
    </PropertyGroup>
    <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Stage|AnyCPU'">
        <DebugType>pdbonly</DebugType>
        <Optimize>true</Optimize>
        <EnvironmentName>Staging</EnvironmentName>
    </PropertyGroup>
    <ItemGroup>
        <Content Remove="appsettings.json" />
        <Content Remove="appsettings.*.json" />
    </ItemGroup>
    <ItemGroup>
        <Content Include="appsettings.json" CopyToOutputDirectory="PreserveNewest" />
        <Content Include="appsettings.*.json" Exclude="appsettings.$(EnvironmentName).json" DependentUpon="appsettings.json" CopyToOutputDirectory="Never" />
        <Content Include="appsettings.$(EnvironmentName).json" DependentUpon="appsettings.json" CopyToOutputDirectory="PreserveNewest" />
    </ItemGroup>

    <Target Name="RenameAppsettings" AfterTargets="Publish">
        <Move SourceFiles="$(PublishDir)\appsettings.$(EnvironmentName).json" DestinationFiles="$(PublishDir)\appsettings.overrides.json" />
    </Target>
</Project>

Um es ein wenig zu erklären, habe ich für jede Konfiguration ein <EnvironmentName> - Element hinzugefügt, damit es während des Erstellungsprozesses verwendet werden kann. Ich verwende appsettings.{EnvironmentName}.json (D. H. appsettings.Staging.json) Nur als "Überschreibungs" -Datei, damit ich die erforderliche JSON-Datei während des Erstellungsprozesses umbenenne. Wenn Sie beispielsweise dotnet publish -c Stage Ausführen, wird die Datei appsettings.Staging.json Im Veröffentlichungsordner veröffentlicht und in appsettings.overrides.json Umbenannt. In Ihrem Program.cs Müssen Sie nur die appsettings.overrides.json - Datei einfügen:

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

Ich hoffe, es hilft!

Randnotiz: Ich füge appsettings.*.json Ein und setze es auf CopyToOutputDirectory="Never", Damit sie beim Entwickeln immer noch in Visual Studio angezeigt werden. Wenn Sie andernfalls nur die appsettings -Datei der aktuellen Umgebung in VS anzeigen möchten, entfernen Sie diese Zeile einfach aus der csproj -Datei.

2
Sensei_Shoh

In VS2017 Hinzufügen mehrerer Umgebungen

schritte Rechtsklick-Projekt -> Hinzufügen -> NewItem - Json-Datei auswählen - Dateiname als 'appsettings.staging.json' oder 'appsettings.production.json' eingeben

Füge die Datei appsettings.staging.json hinzu

Ausgabe Sieht aus wie

2
Balaji Sadhu

Wenn sich ein anderer Benutzer fragt, wie er verschiedene Apps-Einstellungen für mehrere Umgebungen verwenden kann, ist dies eine mögliche Lösung.

dotnet publish --configuration [Debug|Release] kopiert die entsprechende Datei appsettings.json in den Veröffentlichungsordner, wenn *.csproj eine bedingte Logik für diese Dateien aufweist:

  • Deaktivieren Sie zunächst in der .pubxml publish-Profildatei (in Properties-> PublishProfiles von Visual Studio), dass alle Inhaltsdateien standardmäßig enthalten sind
<PropertyGroup>
    <TargetFramework>netcoreapp2.1</TargetFramework>
    <EnableDefaultContentItems>false</EnableDefaultContentItems>
</PropertyGroup>
  • Geben Sie dann die bedingte Debug/Release-Logik an
<Choose>
    <When Condition="'$(Configuration)' == 'Debug'">
      <ItemGroup>
        <None Include="appsettings.json" CopyToOutputDirectory="Always" CopyToPublishDirectory="Always" />
        <None Include="appsettings.prod.json" CopyToOutputDirectory="Never" CopyToPublishDirectory="Never" />
      </ItemGroup>
    </When>
    <When Condition="'$(Configuration)' == 'Release'">
      <ItemGroup>
        <None Include="appsettings.json" CopyToOutputDirectory="Never" CopyToPublishDirectory="Never" />
        <None Include="appsettings.prod.json" CopyToOutputDirectory="Always" CopyToPublishDirectory="Always" />
      </ItemGroup>
    </When>
</Choose>
  • Versuchen Sie schließlich in Startup.cs, beide Dateien zu laden
public Startup(IHostingEnvironment env)
{
    var builder = new ConfigurationBuilder()
        .SetBasePath(env.ContentRootPath)
        .AddJsonFile($"appsettings.prod.json", optional: true, reloadOnChange: true)
        .AddJsonFile($"appsettings.json", optional: true, reloadOnChange: true)
        .AddEnvironmentVariables();

    Configuration = builder.Build();
}

Ich hoffe diese Lösung war hilfreich.

1
Ben

Sie müssen tatsächlich die Umgebungsvariablen hinzufügen, gemäß dem offiziellen Tutorial :

var builder = new ConfigurationBuilder()
    .SetBasePath(env.ContentRootPath)
    .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: false, reloadOnChange: true)
    // do not forget to add environment variables to your config!
    .AddEnvironmentVariables();
1
VMAtm

Der einfachste Weg, den ich bisher gefunden habe, ist das Bereitstellen aller Konfigurationsdateien und das Entfernen zusätzlicher Dateien, nachdem die Bereitstellung abgeschlossen ist .. Fügen Sie am Ende Ihrer Implementierungsshell oder des Batch-Skripts nur ein paar zusätzliche Zeilen hinzu.

0
incognito

Ich habe diese Frage mit diesem Nuget-Paket gelöst: https://github.com/Microsoft/slow-cheetah/blob/master/doc/transforming_files.md

Die Installation und Verwendung aller Konfigurationen in der Active-Lösungskonfiguration ist so einfach. In meinem Fall wurde eine neue "Test" -Konfiguration für die Testbereitstellung hinzugefügt. 

Danach können Sie diese Erweiterung in VS installieren: https://marketplace.visualstudio.com/items?itemName=vscps.SlowCheetah-XMLTransforms .

Sie können jetzt mit diesem Tool (wie im Handbuch) neue Konfigurations-Subdateien für die .xml- oder .json-Konfigurationseinstellungen in VS erstellen. Zum Beispiel habe ich Debug-, Test- und Release-Dateien (appsettings.Debug.json usw.).

Nächster Schritt - Einrichten der Veröffentlichungsprofile für jede Konfiguration und nach dem Veröffentlichen haben Sie nur eine Datei mit allen erforderlichen Umwandlungen.

Transformationen funktionieren wie eine klassische .json-Envinronment-Transormation in .net-Kernwebanwendungen.

0

Ehrlich gesagt denke ich, dass dies nicht die richtige Aufgabe für eine Build-Pipeline ist. Auch die Veröffentlichungsfunktionen des Dotnet CLI sind sehr begrenzt. Gehen Sie zu externen Tools, wie Tseng es Ihnen gezeigt hat. Die Bereitstellung ist eine andere Domäne mit einer eigenen Komplexität als das Erstellen.

Dotnet cli bietet keine Möglichkeit, externe Tools zu verwenden!

0
Thomas

Sie können MSBuild-Bedingungen verwenden, um optional Dateien in die Kompilierungsausgabe (oder veröffentlichte Ausgabe) aufzunehmen.

<ItemGroup Condition="'$(Configuration)'=='Release'">
  <Content Remove="appsettings.Development.json;appsettings.Staging.json" />
  <None Include="appsettings.Development.json;appsettings.Staging.json" />
</ItemGroup>

Das Obige ignoriert die Dateivarianten Development und Staging appsettings.json, wenn die Kompilierungszielkonfiguration Release ist.

0
Gabe Szabo