Visual Studio-Veröffentlichungsprofile (PUBXML) für die Bereitstellung von ASP.NET Core-AppsVisual Studio publish profiles (.pubxml) for ASP.NET Core app deployment

Von Sayed Ibrahim Hashimi und Rick AndersonBy Sayed Ibrahim Hashimi and Rick Anderson

Dieser Artikel konzertiert sich auf die Verwendung von Visual Studio 2019 oder höher zum Erstellen und Verwenden von Veröffentlichungsprofilen.This document focuses on using Visual Studio 2019 or later to create and use publish profiles. Die Veröffentlichungsprofile, die mit Visual Studio erstellt werden, können mit MSBuild und Visual Studio verwendet werden.The publish profiles created with Visual Studio can be used with MSBuild and Visual Studio. Anweisungen zum Veröffentlichen in Azure finden Sie unter Veröffentlichen einer ASP.NET Core-App in Azure mit Visual Studio.For instructions on publishing to Azure, see Veröffentlichen einer ASP.NET Core-App in Azure mit Visual Studio.

Der Befehl dotnet new mvc generiert eine Projektdatei, die das folgende <Project>-Element auf Stammebene enthält:The dotnet new mvc command produces a project file containing the following root-level <Project> element:

<Project Sdk="Microsoft.NET.Sdk.Web">
    <!-- omitted for brevity -->
</Project>

Das Sdk-Attribut des vorhergehenden <Project>-Elements importiert die Eigenschaften und Ziele von MSBuild aus $(MSBuildSDKsPath)\Microsoft.NET.Sdk.Web\Sdk\Sdk.reps bzw. $(MSBuildSDKsPath)\Microsoft.NET.Sdk.Web\Sdk.The preceding <Project> element's Sdk attribute imports the MSBuild properties and targets from $(MSBuildSDKsPath)\Microsoft.NET.Sdk.Web\Sdk\Sdk.props and $(MSBuildSDKsPath)\Microsoft.NET.Sdk.Web\Sdk\Sdk.targets, respectively. Der Standardspeicherort für $(MSBuildSDKsPath) (mit Visual Studio 2019 Enterprise) ist der Ordner %programfiles(x86)%\Microsoft Visual Studio\2019\Enterprise\MSBuild\Sdks.The default location for $(MSBuildSDKsPath) (with Visual Studio 2019 Enterprise) is the %programfiles(x86)%\Microsoft Visual Studio\2019\Enterprise\MSBuild\Sdks folder.

Microsoft.NET.Sdk.Web (Web-SDK) hängt von anderen SDKs ab, einschließlich Microsoft.NET.Sdk (.NET Core SDK) und Microsoft.NET.Sdk.Razor (Razor SDK).Microsoft.NET.Sdk.Web (Web SDK) depends on other SDKs, including Microsoft.NET.Sdk (.NET Core SDK) and Microsoft.NET.Sdk.Razor (Razor SDK). Die MSBuild-Eigenschaften und -Ziele, die jedem abhängigen SDK zugeordnet sind, werden importiert.The MSBuild properties and targets associated with each dependent SDK are imported. Veröffentlichungsziele importieren basierend auf der verwendeten Veröffentlichungsmethode die entsprechende Gruppe von Zielen.Publish targets import the appropriate set of targets based on the publish method used.

Wenn in MSBuild oder Visual Studio ein Projekt geladen wird, werden die folgenden Aktionen auf hoher Ebene ausgeführt:When MSBuild or Visual Studio loads a project, the following high-level actions occur:

  • Erstellen des ProjektsBuild project
  • Berechnen der zu veröffentlichenden DateienCompute files to publish
  • Veröffentlichen der Dateien auf dem ZielPublish files to destination

Berechnen der ProjektelementeCompute project items

Wenn das Projekt geladen ist, werden die MSBuild-Projektelemente (Dateien) berechnet.When the project is loaded, the MSBuild project items (files) are computed. Der Elementtyp bestimmt, wie die Datei verarbeitet wird.The item type determines how the file is processed. Standardmäßig sind CS-Dateien in der Compile-Elementliste enthalten.By default, .cs files are included in the Compile item list. Dateien in der Compile-Elementliste werden kompiliert.Files in the Compile item list are compiled.

Die Content-Elementliste enthält Dateien, die zusätzlich zu den Buildausgaben veröffentlicht werden.The Content item list contains files that are published in addition to the build outputs. Standardmäßig sind Dateien, die mit den Mustern wwwroot\**, **\*.config und **\*.json übereinstimmen, in der Elementliste Content enthalten.By default, files matching the patterns wwwroot\**, **\*.config, and **\*.json are included in the Content item list. Das wwwroot\** Globmuster stimmt z. B. mit allen Dateien im wwwroot-Ordner und in dessen Unterordnern überein.For example, the wwwroot\** globbing pattern matches all files in the wwwroot folder and its subfolders.

Das Web-SDK importiert das Razor SDK.The Web SDK imports the Razor SDK. Demzufolge sind Dateien, die mit den Mustern **\*.cshtml und **\*.razor übereinstimmen, in der Elementliste Content enthalten.As a result, files matching the patterns **\*.cshtml and **\*.razor are also included in the Content item list.

Das Web-SDK importiert das Razor SDK.The Web SDK imports the Razor SDK. Demzufolge sind Dateien, die mit dem Muster **\*.cshtml übereinstimmen, in der Elementliste Content enthalten.As a result, files matching the **\*.cshtml pattern are also included in the Content item list.

Um eine Datei explizit der Veröffentlichungsliste hinzuzufügen, fügen Sie die Datei, wie im Abschnitt Includedateien gezeigt, direkt der CSPROJ-Datei hinzu.To explicitly add a file to the publish list, add the file directly in the .csproj file as shown in the Include Files section.

Wenn Sie auf die Schaltfläche Veröffentlichen in Visual Studio klicken oder aus der Befehlszeile veröffentlichen:When selecting the Publish button in Visual Studio or when publishing from the command line:

  • Die Eigenschaften und Elemente werden berechnet (die Dateien, die für den Build benötigt werden).The properties/items are computed (the files that are needed to build).
  • Nur Visual Studio: NuGet-Pakete werden wiederhergestellt.Visual Studio only: NuGet packages are restored. (Die Wiederherstellung muss explizit vom Benutzer auf der CLI durchgeführt werden.)(Restore needs to be explicit by the user on the CLI.)
  • Das Projekt wird erstellt.The project builds.
  • Die zu veröffentlichenden Elemente werden berechnet (die Dateien, die für die Veröffentlichung benötigt werden).The publish items are computed (the files that are needed to publish).
  • Das Projekt wird veröffentlicht (die berechneten Dateien werden in das Veröffentlichungsziel kopiert).The project is published (the computed files are copied to the publish destination).

Wenn ein ASP.NET Core-Projekt auf Microsoft.NET.Sdk.Web in der Projektdatei verweist, wird eine app_offline.htm-Datei im Stammverzeichnis des Verzeichnisses der Web-App abgelegt.When an ASP.NET Core project references Microsoft.NET.Sdk.Web in the project file, an app_offline.htm file is placed at the root of the web app directory. Wenn die Datei vorhanden ist, fährt das ASP.NET Core Module die App ordnungsgemäß herunter und verarbeitet die Datei app_offline.htm während der Bereitstellung.When the file is present, the ASP.NET Core Module gracefully shuts down the app and serves the app_offline.htm file during the deployment. Weitere Informationen finden Sie unter Konfigurationsreferenz für das ASP.NET Core-Modul.For more information, see the ASP.NET Core Module configuration reference.

Grundlegendes zur Veröffentlichung über die BefehlszeileBasic command-line publishing

Die Veröffentlichung über die Befehlszeile funktioniert auf allen von .NET Core unterstützten Plattformen und setzt Visual Studio nicht voraus.Command-line publishing works on all .NET Core-supported platforms and doesn't require Visual Studio. In den folgenden Beispielen wird der Befehl dotnet publish der .NET Core-CLI im Projektverzeichnis ausgeführt (das die Datei CSPROJ enthält).In the following examples, the .NET Core CLI's dotnet publish command is run from the project directory (which contains the .csproj file). Wenn der Projektordner nicht das aktuelle Arbeitsverzeichnis ist, übergeben Sie den Projektdateipfad explizit.If the project folder isn't the current working directory, explicitly pass in the project file path. Zum Beispiel:For example:

dotnet publish C:\Webs\Web1

Führen Sie die folgenden Befehle zum Erstellen und Veröffentlichen eine Web-App aus:Run the following commands to create and publish a web app:

dotnet new mvc
dotnet publish

Der Befehl dotnet publish erzeugt eine Abwandlung der folgenden Ausgabe:The dotnet publish command produces a variation of the following output:

C:\Webs\Web1>dotnet publish
Microsoft (R) Build Engine version {VERSION} for .NET Core
Copyright (C) Microsoft Corporation. All rights reserved.

  Restore completed in 36.81 ms for C:\Webs\Web1\Web1.csproj.
  Web1 -> C:\Webs\Web1\bin\Debug\{TARGET FRAMEWORK MONIKER}\Web1.dll
  Web1 -> C:\Webs\Web1\bin\Debug\{TARGET FRAMEWORK MONIKER}\Web1.Views.dll
  Web1 -> C:\Webs\Web1\bin\Debug\{TARGET FRAMEWORK MONIKER}\publish\

Das Standardformat des Veröffentlichungsordners ist bin\Debug\{ZIELFRAMEWORKMONIKER}\publish\ .The default publish folder format is bin\Debug\{TARGET FRAMEWORK MONIKER}\publish\. Dies ist dann z. B bin\Debug\netcoreapp2.2\publish\ .For example, bin\Debug\netcoreapp2.2\publish\.

Der folgende Befehl gibt einen Release-Build und das Veröffentlichungsverzeichnis an:The following command specifies a Release build and the publishing directory:

dotnet publish -c Release -o C:\MyWebs\test

Der Befehl dotnet publish ruft MSBuild auf, welches das Publish-Ziel aufruft.The dotnet publish command calls MSBuild, which invokes the Publish target. Alle Parameter, die an dotnet publish übergeben werden, werden an MSBuild übergeben.Any parameters passed to dotnet publish are passed to MSBuild. Die Parameter -c und -o verweisen auf die MSBuild-Eigenschaften Configuration bzw. OutputPath.The -c and -o parameters map to MSBuild's Configuration and OutputPath properties, respectively.

MSBuild-Eigenschaften können mithilfe eines der folgenden Formate übergeben werden:MSBuild properties can be passed using either of the following formats:

  • p:<NAME>=<VALUE>
  • /p:<NAME>=<VALUE>

Der folgende Befehl veröffentlicht z. B. einen Release-Build in einer Netzwerkfreigabe.For example, the following command publishes a Release build to a network share. Die Netzwerkfreigabe wird durch führende Schrägstriche ( //r8/ ) angegeben und funktioniert auf allen Plattformen, die von .NET Core unterstützt werden.The network share is specified with forward slashes (//r8/) and works on all .NET Core supported platforms.

dotnet publish -c Release /p:PublishDir=//r8/release/AdminWeb

Versichern Sie sich, dass die veröffentlichte App für die Bereitstellung nicht ausgeführt wird.Confirm that the published app for deployment isn't running. Die Dateien im Ordner publish sind gesperrt, wenn die App ausgeführt wird.Files in the publish folder are locked when the app is running. Die Bereitstellung kann nicht erfolgen, da die gesperrten Dateien nicht kopiert werden können.Deployment can't occur because locked files can't be copied.

VeröffentlichungsprofilePublish profiles

In diesem Abschnitt wird Visual Studio 2019 oder höher verwendet, um ein Veröffentlichungsprofil zu erstellen.This section uses Visual Studio 2019 or later to create a publishing profile. Nachdem das Profil erstellt ist, ist Veröffentlichung aus Visual Studio oder über die Befehlszeile möglich.Once the profile is created, publishing from Visual Studio or the command line is available. Veröffentlichungsprofile können den Veröffentlichungsprozess vereinfachen, und eine beliebige Anzahl von Profilen kann vorhanden sein.Publish profiles can simplify the publishing process, and any number of profiles can exist.

Erstellen Sie ein Veröffentlichungsprofil in Visual Studio durch Auswahl eines der folgenden Pfade:Create a publish profile in Visual Studio by choosing one of the following paths:

  • Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf das Projekt, und wählen Sie Veröffentlichen aus.Right-click the project in Solution Explorer and select Publish.
  • Wählen Sie {PROJEKTNAME} veröffentlichen im Menü Build aus.Select Publish {PROJECT NAME} from the Build menu.

Die Registerkarte Veröffentlichen der Seite für App-Funktionen wird angezeigt.The Publish tab of the app capabilities page is displayed. Wenn das Projekt kein Veröffentlichungsprofil enthält, wird die Seite Veröffentlichungsziel auswählen angezeigt.If the project lacks a publish profile, the Pick a publish target page is displayed. Sie können aus den folgenden Veröffentlichungszielen wählen:You're asked to select one of the following publish targets:

  • Azure App ServiceAzure App Service
  • Azure App Service für LinuxAzure App Service on Linux
  • Azure Virtual MachinesAzure Virtual Machines
  • OrdnerFolder
  • IIS, FTP, Web Deploy (für einen beliebigen Webserver)IIS, FTP, Web Deploy (for any web server)
  • Profil importierenImport Profile

Unter Übersicht über die Bereitstellung in Visual Studio erfahren Sie, wie Sie das ideale Veröffentlichungsziel bestimmen.To determine the most appropriate publish target, see What publishing options are right for me.

Wenn Ordner als Veröffentlichungsziel ausgewählt ist, geben Sie einen Ordnerpfad ein, um die veröffentlichten Objekte zu speichern.When the Folder publish target is selected, specify a folder path to store the published assets. Der Standardordnerpfad ist bin\{PROJEKTKONFIGURATION}\{ZIELFRAMEWORKMONIKER}\publish\ .The default folder path is bin\{PROJECT CONFIGURATION}\{TARGET FRAMEWORK MONIKER}\publish\. Dies ist dann z. B. bin\Release\netcoreapp2.2\publish\ .For example, bin\Release\netcoreapp2.2\publish\. Klicken Sie auf die Schaltfläche Profil erstellen, um den Vorgang abzuschließen.Select the Create Profile button to finish.

Sobald ein Veröffentlichungsprofil erstellt wurde, ändert sich der Inhalt der Registerkarte Veröffentlichen.Once a publish profile is created, the Publish tab's content changes. Das neu erstellte Profil wird in einer Dropdownliste angezeigt.The newly created profile appears in a drop-down list. Klicken Sie unter der Dropdownliste auf Neues Profil erstellen, um ein weiteres neues Profil zu erstellen.Below the drop-down list, select Create new profile to create another new profile.

Das Visual Studio-Veröffentlichungstool erstellt die MSBuild-Datei Properties/PublishProfiles/{PROFILNAME}.pubxml, in der das Veröffentlichungsprofil beschrieben wird.Visual Studio's publish tool produces a Properties/PublishProfiles/{PROFILE NAME}.pubxml MSBuild file describing the publish profile. Die PUBXML-Datei:The .pubxml file:

  • enthält Veröffentlichungskonfigurationseinstellungen und wird vom Veröffentlichungsprozess verwendet.Contains publish configuration settings and is consumed by the publishing process.
  • kann geändert werden, um den Build- und Veröffentlichungsprozess anzupassen.Can be modified to customize the build and publish process.

Beim Veröffentlichen in einem Azure-Ziel enthält die PUBXML-Datei Ihre Azure-Abonnement-ID.When publishing to an Azure target, the .pubxml file contains your Azure subscription identifier. Bei diesem Zieltyp wird vom Hinzufügen der Datei zur Quellkontrolle abgeraten.With that target type, adding this file to source control is discouraged. Beim Veröffentlichen auf einem Nicht-Azure-Ziel kann die PUBXML-Datei eingecheckt werden.When publishing to a non-Azure target, it's safe to check in the .pubxml file.

Vertrauliche Informationen (z.B. das Kennwort für die Veröffentlichung) werden pro Benutzer/Computer verschlüsselt.Sensitive information (like the publish password) is encrypted on a per user/machine level. Sie werden in der Datei Properties/PublishProfiles/{PROFILNAME}.pubxml.user gespeichert.It's stored in the Properties/PublishProfiles/{PROFILE NAME}.pubxml.user file. Da diese Datei vertrauliche Informationen enthalten kann, sollte sie nicht in die Quellverwaltung eingecheckt werden.Because this file can store sensitive information, it shouldn't be checked into source control.

Mehr Informationen zum Veröffentlichen einer ASP.NET Core-Web-App finden Sie unter Hosten und Bereitstellen von ASP.NET Core.For an overview of how to publish an ASP.NET Core web app, see Hosten und Bereitstellen von ASP.NET Core. Die MSBuild-Tasks und -Ziele, die zum Veröffentlichen einer ASP.NET Core-Web-App erforderlich sind, sind als Open-Source-Code im Repository dotnet/websdk verfügbar.The MSBuild tasks and targets necessary to publish an ASP.NET Core web app are open-source in the dotnet/websdk repository.

Die folgenden Befehle können Ordner, MSDeploy und Kudu-Veröffentlichungsprofile verwenden.The following commands can use folder, MSDeploy, and Kudu publish profiles. Da MSDeploy nicht plattformübergreifend unterstützt wird, werden die folgenden MSDeploy-Optionen nur unter Windows unterstützt:Because MSDeploy lacks cross-platform support, the following MSDeploy options are supported only on Windows.

Ordner (funktioniert plattformübergreifend):Folder (works cross-platform):

dotnet publish WebApplication.csproj /p:PublishProfile=<FolderProfileName>
dotnet build WebApplication.csproj /p:DeployOnBuild=true /p:PublishProfile=<FolderProfileName>

MSDeploy:MSDeploy:

dotnet publish WebApplication.csproj /p:PublishProfile=<MsDeployProfileName> /p:Password=<DeploymentPassword>
dotnet build WebApplication.csproj /p:DeployOnBuild=true /p:PublishProfile=<MsDeployProfileName> /p:Password=<DeploymentPassword>

MSDeploy-Paket:MSDeploy package:

dotnet publish WebApplication.csproj /p:PublishProfile=<MsDeployPackageProfileName>
dotnet build WebApplication.csproj /p:DeployOnBuild=true /p:PublishProfile=<MsDeployPackageProfileName>

In den vorherigen Beispielen:In the preceding examples:

  • dotnet publish und dotnet build unterstützen Kudu-APIs zur Veröffentlichung in Azure von jeder Plattform aus.dotnet publish and dotnet build support Kudu APIs to publish to Azure from any platform. Die Visual Studio-Veröffentlichung unterstützt die Kudu-APIs, wird für die plattformübergreifende Veröffentlichung in Azure aber vom WebSDK unterstützt.Visual Studio publish supports the Kudu APIs, but it's supported by WebSDK for cross-platform publish to Azure.
  • Übergeben Sie DeployOnBuild nicht an den dotnet publish-Befehl.Don't pass DeployOnBuild to the dotnet publish command.

Weitere Informationen finden Sie unter Microsoft.NET.Sdk.Publish.For more information, see Microsoft.NET.Sdk.Publish.

Fügen Sie dem Projektordner Properties/PublishProfiles ein Veröffentlichungsprofil mit folgendem Inhalt hinzu:Add a publish profile to the project's Properties/PublishProfiles folder with the following content:

<Project>
  <PropertyGroup>
    <PublishProtocol>Kudu</PublishProtocol>
    <PublishSiteName>nodewebapp</PublishSiteName>
    <UserName>username</UserName>
    <Password>password</Password>
  </PropertyGroup>
</Project>

Beispiel für OrdnerveröffentlichungFolder publish example

Verwenden Sie einen der folgenden Befehle, wenn Sie mit einem Profil namens FolderProfile veröffentlichen:When publishing with a profile named FolderProfile, use any of the following commands:

dotnet publish /p:Configuration=Release /p:PublishProfile=FolderProfile`
dotnet build /p:DeployOnBuild=true /p:PublishProfile=FolderProfile
msbuild /p:DeployOnBuild=true /p:PublishProfile=FolderProfile

Der .NET Core-CLI-Befehl dotnet build ruft msbuild auf, um den Build- und Veröffentlichungsprozess auszuführen.The .NET Core CLI's dotnet build command calls msbuild to run the build and publish process. Die Befehle dotnet build und msbuild sind bei der Übergabe eines Ordnerprofils gleichwertig.The dotnet build and msbuild commands are equivalent when passing in a folder profile. Wenn Sie msbuild direkt in Windows aufrufen, wird die .NET Framework-Version von MSBuild verwendet.When calling msbuild directly on Windows, the .NET Framework version of MSBuild is used. Wenn Sie dotnet build in einem Profil ohne Ordner aufrufen:Calling dotnet build on a non-folder profile:

  • wird das msbuild-Objekt aufgerufen, das MSDeploy verwendet.Invokes msbuild, which uses MSDeploy.
  • führt dies zu einem Fehler (auch unter Windows).Results in a failure (even when running on Windows). Rufen Sie msbuild direkt auf, um eine Veröffentlichung mit einem Profil ohne Ordner durchzuführen.To publish with a non-folder profile, call msbuild directly.

Der folgende Ordner „Veröffentlichungsprofil“ wurde mit Visual Studio erstellt und veröffentlicht in eine Netzwerkfreigabe.The following folder publish profile was created with Visual Studio and publishes to a network share:

<?xml version="1.0" encoding="utf-8"?>
<!--
This file is used by the publish/package process of your Web project.
You can customize the behavior of this process by editing this 
MSBuild file.
-->
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <PropertyGroup>
    <WebPublishMethod>FileSystem</WebPublishMethod>
    <PublishProvider>FileSystem</PublishProvider>
    <LastUsedBuildConfiguration>Release</LastUsedBuildConfiguration>
    <LastUsedPlatform>Any CPU</LastUsedPlatform>
    <SiteUrlToLaunchAfterPublish />
    <LaunchSiteAfterPublish>True</LaunchSiteAfterPublish>
    <ExcludeApp_Data>False</ExcludeApp_Data>
    <PublishFramework>netcoreapp1.1</PublishFramework>
    <ProjectGuid>c30c453c-312e-40c4-aec9-394a145dee0b</ProjectGuid>
    <publishUrl>\\r8\Release\AdminWeb</publishUrl>
    <DeleteExistingFiles>False</DeleteExistingFiles>
  </PropertyGroup>
</Project>

Im vorherigen Beispiel:In the preceding example:

  • Die Eigenschaft <ExcludeApp_Data> ist nur vorhanden, um die XML-Schemaanforderung zu erfüllen.The <ExcludeApp_Data> property is present merely to satisfy an XML schema requirement. Die Eigenschaft <ExcludeApp_Data> wirkt sich nicht auf den Veröffentlichungsprozess aus, auch wenn es den Ordner App_Data am Projektstamm gibt.The <ExcludeApp_Data> property has no effect on the publish process, even if there's an App_Data folder in the project root. Der Ordner App_Data wird genauso wie in ASP.NET 4.x-Projekten behandelt.The App_Data folder doesn't receive special treatment as it does in ASP.NET 4.x projects.

  • Die <LastUsedBuildConfiguration>-Eigenschaft ist auf Release festgelegt.The <LastUsedBuildConfiguration> property is set to Release. Bei der Veröffentlichung von Visual Studio wird der <LastUsedBuildConfiguration>-Wert mithilfe des Werts festgelegt, der beim Starten des Veröffentlichungsprozesses vorliegt.When publishing from Visual Studio, the value of <LastUsedBuildConfiguration> is set using the value when the publish process is started. <LastUsedBuildConfiguration> ist ein Sonderfall und sollte nicht in einer importierten MSBuild-Datei überschrieben werden.<LastUsedBuildConfiguration> is special and shouldn't be overridden in an imported MSBuild file. Diese Eigenschaft kann aber über die Befehlszeile mit einer der folgenden Vorgehensweisen überschrieben werden.This property can, however, be overridden from the command line using one of the following approaches.

    • Mit der .NET Core-CLI:Using the .NET Core CLI:

      dotnet publish /p:Configuration=Release /p:PublishProfile=FolderProfile
      
      dotnet build -c Release /p:DeployOnBuild=true /p:PublishProfile=FolderProfile
      
    • Verwenden von MSBuild:Using MSBuild:

      msbuild /p:Configuration=Release /p:DeployOnBuild=true /p:PublishProfile=FolderProfile
      

    Weitere Informationen finden Sie unter MSBuild: how to set the configuration property (MSBuild: Festlegen der Konfigurationseigenschaft).For more information, see MSBuild: how to set the configuration property.

Veröffentlichen auf einen MSDeploy-Endpunkt von der BefehlszeilePublish to an MSDeploy endpoint from the command line

Im folgenden Beispiel wird von Visual Studio eine ASP.NET Core-Web-App namens AzureWebApp erstellt.The following example uses an ASP.NET Core web app created by Visual Studio named AzureWebApp. Ein Azure Apps-Veröffentlichungsprofil wird mit Visual Studio hinzugefügt.An Azure Apps publish profile is added with Visual Studio. Weitere Informationen zum Erstellen eines Profils finden Sie unter im Abschnitt Veröffentlichungsprofile.For more information on how to create a profile, see the Publish profiles section.

Um eine App mit einem Veröffentlichungsprofil bereitzustellen, führen Sie den Befehl msbuild an einer Developer-Eingabeaufforderung von Visual Studio aus.To deploy the app using a publish profile, execute the msbuild command from a Visual Studio Developer Command Prompt. Die Eingabeaufforderung finden Sie im Ordner Visual Studio im Start-Menü auf der Windows-Taskleiste.The command prompt is available in the Visual Studio folder of the Start menu on the Windows taskbar. Für einfacheren Zugriff können Sie die Eingabeaufforderung zum Menü Tools in Visual Studio hinzufügen.For easier access, you can add the command prompt to the Tools menu in Visual Studio. Weitere Informationen finden Sie unter Developer-Eingabeaufforderung für Visual Studio.For more information, see Developer Command Prompt for Visual Studio.

MSBuild hat die folgende Befehlssyntax:MSBuild uses the following command syntax:

msbuild {PATH} 
    /p:DeployOnBuild=true 
    /p:PublishProfile={PROFILE} 
    /p:Username={USERNAME} 
    /p:Password={PASSWORD}
  • {PATH}: Der Pfad zur Projektdatei der App.{PATH}: Path to the app's project file.
  • {PROFILE}: Der Name des Veröffentlichungsprofils.{PROFILE}: Name of the publish profile.
  • {USERNAME}: Der MSDeploy-Benutzername.{USERNAME}: MSDeploy username. {USERNAME} befindet sich im Veröffentlichungsprofil.The {USERNAME} can be found in the publish profile.
  • {PASSWORD}: Das MSDeploy-Kennwort.{PASSWORD}: MSDeploy password. {PASSWORD} befindet sich in der Datei {PROFILE}.PublishSettings.Obtain the {PASSWORD} from the {PROFILE}.PublishSettings file. Laden Sie die Datei .PublishSettings von einem der folgenden Speicherorte herunter:Download the .PublishSettings file from either:
    • Projektmappen-Explorer: Wählen Sie Ansicht > Cloud-Explorer aus.Solution Explorer: Select View > Cloud Explorer. Stellen Sie eine Verbindung mit Ihrem Azure-Abonnement her.Connect with your Azure subscription. Öffnen Sie App Services.Open App Services. Klicken Sie mit der rechten Maustaste auf die App.Right-click the app. Wählen Sie Veröffentlichungsprofil herunterladen aus.Select Download Publish Profile.
    • Azure-Portal: Wählen Sie Veröffentlichungsprofil abrufen im Bereich Übersicht der Web-App aus.Azure portal: Select Get publish profile in the web app's Overview panel.

Im folgenden Beispiel wird ein Veröffentlichungsprofil namens AzureWebApp – Web Deploy verwendet:The following example uses a publish profile named AzureWebApp - Web Deploy:

msbuild "AzureWebApp.csproj" 
    /p:DeployOnBuild=true 
    /p:PublishProfile="AzureWebApp - Web Deploy" 
    /p:Username="$AzureWebApp" 
    /p:Password=".........."

Ein Veröffentlichungsprofil kann auch mit dem .NET Core-CLI-Befehl dotnet msbuild über eine Windows-Befehlsshell verwendet werden:A publish profile can also be used with the .NET Core CLI's dotnet msbuild command from a Windows command shell:

dotnet msbuild "AzureWebApp.csproj"
    /p:DeployOnBuild=true 
    /p:PublishProfile="AzureWebApp - Web Deploy" 
    /p:Username="$AzureWebApp" 
    /p:Password=".........."

Wichtig

Der Befehl dotnet msbuild ist plattformübergreifend verfügbar und kann ASP.NET Core-Apps unter macOS und Linux kompilieren.The dotnet msbuild command is a cross-platform command and can compile ASP.NET Core apps on macOS and Linux. Allerdings kann MSBuild unter macOS und Linux keine Apps in Azure oder an einem anderen MSDeploy-Endpunkt bereitstellen.However, MSBuild on macOS and Linux isn't capable of deploying an app to Azure or other MSDeploy endpoints.

Festlegen der UmgebungSet the environment

Beziehen Sie die <EnvironmentName>-Eigenschaft in das Veröffentlichungsprofil (PUBXML) oder die Projektdatei ein, um die Umgebung der App festzulegen:Include the <EnvironmentName> property in the publish profile (.pubxml) or project file to set the app's environment:

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

Wenn Sie web.config-Transformationen benötigen (z.B. Umgebungsvariablen basierend auf der Konfiguration, dem Profil oder der Umgebung), finden Sie weitere Informationen unter Transformieren von web.config.If you require web.config transformations (for example, setting environment variables based on the configuration, profile, or environment), see Transformieren von web.config.

Dateien ausschließenExclude files

Wenn Sie ASP.NET Core-Web-Apps veröffentlichen, sind die folgenden Ressourcen enthalten:When publishing ASP.NET Core web apps, the following assets are included:

  • Build-ArtefakteBuild artifacts
  • Ordner und Dateien, die den folgenden Globmustern entsprechen:Folders and files matching the following globbing patterns:
    • **\*.config (Beispiel: web.config)**\*.config (for example, web.config)
    • **\*.json (Beispiel: appsettings.json)**\*.json (for example, appsettings.json)
    • wwwroot\**

MSBuild unterstützt Globmuster.MSBuild supports globbing patterns. Das folgende <Content>-Element unterdrückt beispielsweise das Kopieren von Textdateien (TXT) aus dem Ordner wwwroot/content und allen seinen Unterordnern:For example, the following <Content> element suppresses the copying of text (.txt) files in the wwwroot\content folder and its subfolders:

<ItemGroup>
  <Content Update="wwwroot/content/**/*.txt" CopyToPublishDirectory="Never" />
</ItemGroup>

Das vorstehende Markup kann einem Veröffentlichungsprofil oder der CSPROJ-Datei hinzugefügt werden.The preceding markup can be added to a publish profile or the .csproj file. Wenn es zu der CSPROJ-Datei hinzugefügt wird, wird die Regel zu allen Veröffentlichungsprofilen im Projekt hinzugefügt.When added to the .csproj file, the rule is added to all publish profiles in the project.

Das folgende <MsDeploySkipRules>-Element schließt alle Dateien aus dem Ordner wwwroot\content aus:The following <MsDeploySkipRules> element excludes all files from the wwwroot\content folder:

<ItemGroup>
  <MsDeploySkipRules Include="CustomSkipFolder">
    <ObjectName>dirPath</ObjectName>
    <AbsolutePath>wwwroot\\content</AbsolutePath>
  </MsDeploySkipRules>
</ItemGroup>

<MsDeploySkipRules> löscht die Skip-Ziele von der Bereitstellungsseite nicht.<MsDeploySkipRules> won't delete the skip targets from the deployment site. <Content>-Zieldateien und -ordner werden von der Bereitstellungsseite gelöscht.<Content> targeted files and folders are deleted from the deployment site. Nehmen wir beispielsweise an, dass eine bereitgestellte Web-App folgende Dateien enthält:For example, suppose a deployed web app had the following files:

  • Views/Home/About1.cshtmlViews/Home/About1.cshtml
  • Views/Home/About2.cshtmlViews/Home/About2.cshtml
  • Views/Home/About3.cshtmlViews/Home/About3.cshtml

Wenn folgende <MsDeploySkipRules>-Elemente hinzugefügt werden, würden diese Dateien nicht von der Bereitstellungsseite gelöscht werden.If the following <MsDeploySkipRules> elements are added, those files wouldn't be deleted on the deployment site.

<ItemGroup>
  <MsDeploySkipRules Include="CustomSkipFile">
    <ObjectName>filePath</ObjectName>
    <AbsolutePath>Views\\Home\\About1.cshtml</AbsolutePath>
  </MsDeploySkipRules>

  <MsDeploySkipRules Include="CustomSkipFile">
    <ObjectName>filePath</ObjectName>
    <AbsolutePath>Views\\Home\\About2.cshtml</AbsolutePath>
  </MsDeploySkipRules>

  <MsDeploySkipRules Include="CustomSkipFile">
    <ObjectName>filePath</ObjectName>
    <AbsolutePath>Views\\Home\\About3.cshtml</AbsolutePath>
  </MsDeploySkipRules>
</ItemGroup>

Die vorangehenden <MsDeploySkipRules>-Elemente verhindern, dass übersprungene Dateien bereitgestellt werden.The preceding <MsDeploySkipRules> elements prevent the skipped files from being deployed. Diese Dateien werden nach ihrer Bereitstellung nicht gelöscht.It won't delete those files once they're deployed.

Das folgende <Content>-Element löscht die Zieldateien auf der Bereitstellungsseite:The following <Content> element deletes the targeted files at the deployment site:

<ItemGroup>
  <Content Update="Views/Home/About?.cshtml" CopyToPublishDirectory="Never" />
</ItemGroup>

Die Bereitstellung über die Befehlszeile mit dem vorangehenden <Content>-Element gibt eine Abwandlung der folgenden Ausgabe aus:Using command-line deployment with the preceding <Content> element yields a variation of the following output:

MSDeployPublish:
  Starting Web deployment task from source: manifest(C:\Webs\Web1\obj\Release\{TARGET FRAMEWORK MONIKER}\PubTmp\Web1.SourceManifest.
  xml) to Destination: auto().
  Deleting file (Web11112\Views\Home\About1.cshtml).
  Deleting file (Web11112\Views\Home\About2.cshtml).
  Deleting file (Web11112\Views\Home\About3.cshtml).
  Updating file (Web11112\web.config).
  Updating file (Web11112\Web1.deps.json).
  Updating file (Web11112\Web1.dll).
  Updating file (Web11112\Web1.pdb).
  Updating file (Web11112\Web1.runtimeconfig.json).
  Successfully executed Web deployment task.
  Publish Succeeded.
Done Building Project "C:\Webs\Web1\Web1.csproj" (default targets).

IncludedateienInclude files

Die folgenden Abschnitte beschreiben verschiedene Ansätze für das Einbeziehen von Dateien beim Veröffentlichen.The following sections outline different approaches for file inclusion at publish time. Im Abschnitt Allgemeines Einbeziehen von Dateien wird das Element DotNetPublishFiles verwendet, das von einer Veröffentlichungszieledatei im Web-SDK bereitgestellt wird.The General file inclusion section uses the DotNetPublishFiles item, which is provided by a publish targets file in the Web SDK. Im Abschnitt Selektives Einbeziehen von Dateien wird das Element ResolvedFileToPublish verwendet, das von einer Veröffentlichungszieledatei im .NET Core SDK bereitgestellt wird.The Selective file inclusion section uses the ResolvedFileToPublish item, which is provided by a publish targets file in the .NET Core SDK. Weil das Web-SDK vom .NET Core SDK abhängig ist, können beide Elemente in einem ASP.NET Core-Projekt verwendet werden.Because the Web SDK depends on the .NET Core SDK, either item can be used in an ASP.NET Core project.

Allgemeines Einbeziehen von DateienGeneral file inclusion

Das Element <ItemGroup> im folgenden Beispiel veranschaulicht das Kopieren eines Ordners, der sich außerhalb des Projektverzeichnisses befindet, in einen Ordner der veröffentlichten Website.The following example's <ItemGroup> element demonstrates copying a folder located outside of the project directory to a folder of the published site. Alle Dateien, die dem <ItemGroup>-Element im folgenden Markup-Ausschnitt hinzugefügt werden, werden standardmäßig einbezogen.Any files added to the following markup's <ItemGroup> are included by default.

<ItemGroup>
  <_CustomFiles Include="$(MSBuildProjectDirectory)/../images/**/*" />
  <DotNetPublishFiles Include="@(_CustomFiles)">
    <DestinationRelativePath>wwwroot/images/%(RecursiveDir)%(Filename)%(Extension)</DestinationRelativePath>
  </DotNetPublishFiles>
</ItemGroup>

Das obenstehende Markup:The preceding markup:

  • Kann der CSPROJ-Datei oder dem Veröffentlichungsprofil hinzugefügt werden.Can be added to the .csproj file or the publish profile. Wenn es der CSPROJ-Datei hinzugefügt wird, wird es in jedes Veröffentlichungsprofil im Projekt eingeschlossen.If it's added to the .csproj file, it's included in each publish profile in the project.
  • Deklariert ein _CustomFiles-Element, um Dateien zu speichern, die mit dem Globmuster des Include-Attributs übereinstimmen.Declares a _CustomFiles item to store files matching the Include attribute's globbing pattern. Der Ordner images, auf den im Muster verwiesen wird, befindet sich außerhalb des Projektverzeichnisses.The images folder referenced in the pattern is located outside of the project directory. Die reservierte Eigenschaft$(MSBuildProjectDirectory) löst den absoluten Pfad der Projektdatei auf.A reserved property, named $(MSBuildProjectDirectory), resolves to the project file's absolute path.
  • Stellt eine Liste der zu verarbeitenden DotNetPublishFiles-Elemente bereit.Provides a list of files to the DotNetPublishFiles item. Das <DestinationRelativePath>-Element des Elements ist standardmäßig leer.By default, the item's <DestinationRelativePath> element is empty. Der Standardwert wird im Markup überschrieben und verwendet bekannte Elementmetadaten wie z. B. %(RecursiveDir).The default value is overridden in the markup and uses well-known item metadata such as %(RecursiveDir). Der innere Text stellt den Ordner wwwroot/images der veröffentlichten Website dar.The inner text represents the wwwroot/images folder of the published site.

Selektives Einbeziehen von DateienSelective file inclusion

Der markierte Markup-Code im folgenden Beispiel veranschaulicht Folgendes:The highlighted markup in the following example demonstrates:

  • Das Kopieren einer Datei, die sich außerhalb eines Projekts befindet, in den wwwroot-Ordner der veröffentlichten Website.Copying a file located outside of the project into the published site's wwwroot folder. Der Dateiname ReadMe2.md wird beibehalten.The file name of ReadMe2.md is maintained.
  • Ausschließen des Ordners wwwroot\Content.Excluding the wwwroot\Content folder.
  • Ausschließen von Views\Home\About2.cshtml.Excluding Views\Home\About2.cshtml.
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" 
         xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <PropertyGroup>
    <WebPublishMethod>FileSystem</WebPublishMethod>
    <PublishProvider>FileSystem</PublishProvider>
    <LastUsedBuildConfiguration>Release</LastUsedBuildConfiguration>
    <LastUsedPlatform>Any CPU</LastUsedPlatform>
    <SiteUrlToLaunchAfterPublish />
    <LaunchSiteAfterPublish>True</LaunchSiteAfterPublish>
    <ExcludeApp_Data>False</ExcludeApp_Data>
    <PublishFramework />
    <ProjectGuid>afa9f185-7ce0-4935-9da1-ab676229d68a</ProjectGuid>
    <publishUrl>bin\Release\PublishOutput</publishUrl>
    <DeleteExistingFiles>False</DeleteExistingFiles>
  </PropertyGroup>
  <ItemGroup>
    <ResolvedFileToPublish Include="..\ReadMe2.md">
      <RelativePath>wwwroot\ReadMe2.md</RelativePath>
    </ResolvedFileToPublish>

    <Content Update="wwwroot\Content\**\*" CopyToPublishDirectory="Never" />
    <Content Update="Views\Home\About2.cshtml" CopyToPublishDirectory="Never" />
  </ItemGroup>
</Project>

Im vorherigen Beispiel wird das Element ResolvedFileToPublish verwendet, dessen Standardverhalten darin besteht, die im Include-Attribut bereitgestellten Dateien in die veröffentlichte Website zu kopieren.The preceding example uses the ResolvedFileToPublish item, whose default behavior is to always copy the files provided in the Include attribute to the published site. Sie können das Standardverhalten überschreiben, indem Sie ein untergeordnetes <CopyToPublishDirectory>-Element mit dem inneren Text Never oder PreserveNewest einbeziehen.Override the default behavior by including a <CopyToPublishDirectory> child element with inner text of either Never or PreserveNewest. Zum Beispiel:For example:

<ResolvedFileToPublish Include="..\ReadMe2.md">
  <RelativePath>wwwroot\ReadMe2.md</RelativePath>
  <CopyToPublishDirectory>PreserveNewest</CopyToPublishDirectory>
</ResolvedFileToPublish>

Weitere Bereitstellungsbeispiele finden Sie in der README-Datei des Web SDK.For more deployment samples, see the Web SDK README file.

Führen Sie ein Ziel vor oder nach der Veröffentlichung aus.Run a target before or after publishing

Die integrierten Ziele BeforePublish und AfterPublish führen ein Ziel vor oder nach dem Veröffentlichungsziel aus.The built-in BeforePublish and AfterPublish targets execute a target before or after the publish target. Fügen Sie die folgenden Elemente dem Veröffentlichungsprofil hinzu, um Konsolenmeldungen vor und nach der Veröffentlichung zu protokollieren:Add the following elements to the publish profile to log console messages both before and after publishing:

<Target Name="CustomActionsBeforePublish" BeforeTargets="BeforePublish">
    <Message Text="Inside BeforePublish" Importance="high" />
  </Target>
  <Target Name="CustomActionsAfterPublish" AfterTargets="AfterPublish">
    <Message Text="Inside AfterPublish" Importance="high" />
</Target>

Veröffentlichen auf einem Server unter Verwendung eines nicht vertrauenswürdigen ZertifikatsPublish to a server using an untrusted certificate

Fügen Sie die Eigenschaft <AllowUntrustedCertificate> mit dem Wert True auf dem Veröffentlichungsprofil hinzu:Add the <AllowUntrustedCertificate> property with a value of True to the publish profile:

<PropertyGroup>
  <AllowUntrustedCertificate>True</AllowUntrustedCertificate>
</PropertyGroup>

Der Kudu-DienstThe Kudu service

Verwenden Sie zum Anzeigen der Dateien in einer Web-App-Bereitstellung von Azure App Service den Kudu-Dienst.To view the files in an Azure App Service web app deployment, use the Kudu service. Fügen Sie das Token scm an den Namen Ihrer Web-App an.Append the scm token to the web app name. Zum Beispiel:For example:

URLURL ErgebnisResult
http://mysite.azurewebsites.net/ WebanwendungWeb App
http://mysite.scm.azurewebsites.net/ Der Kudu-DienstKudu service

Wählen Sie das Menüelement Debugging-Konsole, aus, um Dateien anzuzeigen, zu bearbeiten, zu löschen oder hinzuzufügen.Select the Debug Console menu item to view, edit, delete, or add files.

Zusätzliche RessourcenAdditional resources