Profile publikowania programu Visual Studio (pubxml) dla wdrożenia aplikacji ASP.NET Core

  • Artykuł

Autor : Sayed Ibrahim Hashimi i Rick Anderson

Ten dokument koncentruje się na tworzeniu i używaniu profilów publikowania przy użyciu programu Visual Studio 2019 lub nowszego. Profile publikowania utworzone za pomocą programu Visual Studio mogą być używane w programach MSBuild i Visual Studio. Aby uzyskać instrukcje dotyczące publikowania na platformie Azure, zobacz Publikowanie aplikacji ASP.NET Core na platformie Azure przy użyciu programu Visual Studio.

Polecenie dotnet new mvc tworzy plik projektu zawierający następujący element projektu> na poziomie <głównym:

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

<Project> Poprzedni atrybut elementu Sdk importuje właściwości i obiekty docelowe MSBuild z $(MSBuildSDKsPath)\Microsoft.NET.Sdk.Web\Sdk\Sdk.props i $(MSBuildSDKsPath)\Microsoft.NET.Sdk.Web\Sdk\Sdk.targets, odpowiednio. Domyślną lokalizacją $(MSBuildSDKsPath) programu (z programem Visual Studio 2019 Enterprise) jest folder %programfiles(x86)%\Microsoft Visual Studio\2019\Enterprise\MSBuild\Sdks .

Microsoft.NET.Sdk.Web (Zestaw SDK sieci Web) zależy od innych zestawów SDK, w tym Microsoft.NET.Sdk (.NET Core SDK) i Microsoft.NET.Sdk.Razor (Razor SDK). Właściwości i obiekty docelowe programu MSBuild skojarzone z każdym zależnym zestawem SDK są importowane. Miejsca docelowe publikowania importuje odpowiedni zestaw obiektów docelowych na podstawie używanej metody publikowania.

Gdy program MSBuild lub Visual Studio ładuje projekt, są wykonywane następujące akcje wysokiego poziomu:

  • Kompilowanie projektu
  • Pliki obliczeniowe do opublikowania
  • Publikowanie plików w miejscu docelowym

Elementy projektu obliczeniowego

Po załadowaniu projektu są obliczane elementy projektu MSBuild (pliki). Typ elementu określa sposób przetwarzania pliku. Domyślnie .cs pliki są uwzględniane na Compile liście elementów. Pliki na Compile liście elementów są kompilowane.

Lista Content elementów zawiera pliki publikowane oprócz danych wyjściowych kompilacji. Domyślnie pliki pasujące do wzorców wwwroot\**, **\*.configi **\*.json są uwzględniane na Content liście elementów. Na przykład wwwroot\**wzorzec globbingu pasuje do wszystkich plików w folderze wwwroot i jego podfolderach.

Zestaw WEB SDK importuje zestaw Razor SDK. W związku z tym pliki pasujące do wzorców **\*.cshtml i **\*.razor również znajdują się na Content liście elementów.

Zestaw WEB SDK importuje zestaw Razor SDK. W związku z tym pliki pasujące do **\*.cshtml wzorca są również uwzględniane na Content liście elementów.

Aby jawnie dodać plik do listy publikowania, dodaj plik bezpośrednio w .csproj pliku, jak pokazano w sekcji Dołączanie plików .

Po wybraniu przycisku Publikuj w programie Visual Studio lub podczas publikowania w wierszu polecenia:

  • Właściwości/elementy są obliczane (pliki potrzebne do skompilowania).
  • Tylko program Visual Studio: pakiety NuGet są przywracane. (Przywracanie musi być jawne przez użytkownika w interfejsie wiersza polecenia).
  • Kompiluje się projekt.
  • Elementy publikowania są obliczane (pliki potrzebne do opublikowania).
  • Projekt jest publikowany (obliczone pliki są kopiowane do miejsca docelowego publikowania).

Gdy projekt ASP.NET Core odwołuje się Microsoft.NET.Sdk.Web do pliku projektu, app_offline.htm plik jest umieszczany w katalogu głównym katalogu aplikacji internetowej. Gdy plik występuje, moduł ASP.NET Core Module bezpiecznie zamyka aplikację i obsługuje plik app_offline.htm podczas wdrażania. Aby uzyskać więcej informacji, zobacz dokumentację konfiguracji modułu ASP.NET Core Module.

Podstawowe publikowanie w wierszu polecenia

Publikowanie wiersza polecenia działa na wszystkich platformach obsługiwanych przez platformę .NET Core i nie wymaga programu Visual Studio. W poniższych przykładach polecenie dotnet publish interfejsu wiersza polecenia platformy .NET Core jest uruchamiane z katalogu projektu (który zawiera .csproj plik). Jeśli folder projektu nie jest bieżącym katalogiem roboczym, jawnie przekaż ścieżkę pliku projektu. Przykład:

dotnet publish C:\Webs\Web1

Uruchom następujące polecenia, aby utworzyć i opublikować aplikację internetową:

dotnet new mvc
dotnet publish

Polecenie dotnet publish generuje odmianę następujących danych wyjściowych:

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\

Domyślny format folderu publikowania to bin\Debug\{TARGET FRAMEWORK MONIKER}\publish\. Na przykład bin\Debug\netcoreapp2.2\publish\.

Następujące polecenie określa kompilację Release i katalog publikowania:

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

Polecenie dotnet publish wywołuje program MSBuild, który wywołuje obiekt docelowy Publish . Wszystkie przekazane dotnet publish parametry są przekazywane do programu MSBuild. Parametry -c i -o są mapować odpowiednio na właściwości i OutputPath msbuildConfiguration.

Właściwości programu MSBuild można przekazać przy użyciu jednego z następujących formatów:

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

Na przykład następujące polecenie publikuje kompilację Release w udziale sieciowym. Udział sieciowy jest określony z ukośnikami (//r8/) i działa na wszystkich obsługiwanych platformach .NET Core.

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

Upewnij się, że opublikowana aplikacja do wdrożenia nie jest uruchomiona. Pliki w folderze publikowania są zablokowane, gdy aplikacja jest uruchomiona. Nie można przeprowadzić wdrażania, ponieważ nie można skopiować zablokowanych plików.

Profile publikowania

Ta sekcja używa programu Visual Studio 2019 lub nowszego do utworzenia profilu publikowania. Po utworzeniu profilu publikowanie z poziomu programu Visual Studio lub wiersza polecenia jest dostępne. Profile publikowania mogą uprościć proces publikowania, a dowolna liczba profilów może istnieć.

Utwórz profil publikowania w programie Visual Studio, wybierając jedną z następujących ścieżek:

  • Kliknij projekt prawym przyciskiem myszy w Eksploratorze rozwiązań i wybierz pozycję Opublikuj.
  • Wybierz pozycję Publikuj {NAZWA PROJEKTU} z menu Kompilacja.

Zostanie wyświetlona karta Publikowanie na stronie możliwości aplikacji. Jeśli projekt nie ma profilu publikowania, zostanie wyświetlona strona Wybierz element docelowy publikowania. Zostanie wyświetlony monit o wybranie jednego z następujących elementów docelowych publikowania:

  • Azure App Service
  • usługa aplikacja systemu Azure w systemie Linux
  • Azure Virtual Machines
  • Folder
  • USŁUGI IIS, FTP, Web Deploy (dla dowolnego serwera internetowego)
  • Importowanie profilu

Aby określić najbardziej odpowiedni element docelowy publikowania, zobacz Jakie opcje publikowania są odpowiednie dla mnie.

Po wybraniu miejsca docelowego publikowania folderu określ ścieżkę folderu do przechowywania opublikowanych zasobów. Domyślna ścieżka folderu to bin\{PROJECT CONFIGURATION}\{TARGET FRAMEWORK MONIKER}\publish\. Na przykład bin\Release\netcoreapp2.2\publish\. Wybierz przycisk Utwórz profil, aby zakończyć.

Po utworzeniu profilu publikowania zawartość karty Publikuj zmieni się. Nowo utworzony profil zostanie wyświetlony na liście rozwijanej. Poniżej listy rozwijanej wybierz pozycję Utwórz nowy profil , aby utworzyć inny nowy profil.

Narzędzie publikowania programu Visual Studio tworzy plik Properties/PublishProfiles/{PROFILE NAME}.pubxml MSBuild opisujący profil publikowania. Plik .pubxml:

  • Zawiera ustawienia konfiguracji publikowania i jest używany przez proces publikowania.
  • Można zmodyfikować w celu dostosowania procesu kompilacji i publikowania.

Podczas publikowania w obiekcie docelowym platformy Azure plik pubxml zawiera identyfikator subskrypcji platformy Azure. W przypadku tego typu docelowego nie zaleca się dodawania tego pliku do kontroli źródła. Podczas publikowania w obiekcie docelowym spoza platformy Azure można bezpiecznie zaewidencjonować plik pubxml .

Informacje poufne (takie jak hasło publikowania) są szyfrowane na poziomie użytkownika/komputera. Jest on przechowywany w pliku Properties/PublishProfiles/{PROFILE NAME}.pubxml.user . Ponieważ ten plik może przechowywać poufne informacje, nie powinien być zaewidencjonowany w kontroli źródła.

Aby zapoznać się z omówieniem sposobu publikowania aplikacji internetowej ASP.NET Core, zobacz Hostowanie i wdrażanie ASP.NET Core. Zadania i cele programu MSBuild niezbędne do opublikowania aplikacji internetowej platformy ASP.NET Core są typu open source w repozytorium dotnet/websdk.

Następujące polecenia mogą używać profilów publikowania folderów, msDeploy i Kudu . Ponieważ narzędzie MSDeploy nie obsługuje wielu platform, następujące opcje msDeploy są obsługiwane tylko w systemie Windows.

Folder (działa międzyplatformowo):

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

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

MSDeploy:

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

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

Pakiet MSDeploy:

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

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

W poprzednich przykładach:

  • dotnet publish obsługują interfejsy dotnet build API Kudu do publikowania na platformie Azure z dowolnej platformy. Publikowanie w programie Visual Studio obsługuje interfejsy API Kudu, ale jest obsługiwane przez zestaw WebSDK na potrzeby publikowania międzyplatformowego na platformie Azure.
  • Nie przekazuj DeployOnBuilddotnet publish do polecenia .

Aby uzyskać więcej informacji, zobacz Microsoft.NET.Sdk.Publish.

Dodaj profil publikowania do folderu Properties/PublishProfiles projektu z następującą zawartością:

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

Przykład publikowania folderu

Podczas publikowania przy użyciu profilu o nazwie FolderProfile użyj dowolnego z następujących poleceń:

dotnet publish /p:Configuration=Release /p:PublishProfile=FolderProfile

dotnet build /p:DeployOnBuild=true /p:PublishProfile=FolderProfile

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

Polecenie dotnet build interfejsu wiersza polecenia platformy .NET Core wywołuje polecenie msbuild w celu uruchomienia procesu kompilacji i publikowania. Polecenia dotnet build i msbuild są równoważne podczas przekazywania profilu folderu. Podczas wywoływania msbuild bezpośrednio w systemie Windows używana jest wersja programu .NET Framework programu MSBuild. Wywoływanie dotnet build profilu innego niż folder:

  • Wywołuje metodę msbuild, która używa narzędzia MSDeploy.
  • Powoduje awarię (nawet w przypadku uruchamiania w systemie Windows). Aby opublikować za pomocą profilu innego niż folder, wywołaj metodę msbuild bezpośrednio.

Następujący profil publikowania folderu został utworzony za pomocą programu Visual Studio i opublikowany w udziale sieciowym:

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

W poprzednim przykładzie:

  • Właściwość <ExcludeApp_Data> jest obecna tylko w celu spełnienia wymagania schematu XML. Właściwość <ExcludeApp_Data> nie ma wpływu na proces publikowania, nawet jeśli w katalogu głównym projektu znajduje się folder App_Data . Folder App_Data nie otrzymuje specjalnego traktowania, podobnie jak w projektach ASP.NET 4.x.
  • Właściwość jest ustawiona <LastUsedBuildConfiguration> na Release. Podczas publikowania w programie Visual Studio wartość <LastUsedBuildConfiguration> jest ustawiana przy użyciu wartości podczas uruchamiania procesu publikowania. <LastUsedBuildConfiguration> jest specjalny i nie powinien być zastępowany w zaimportowanym pliku MSBuild. Tę właściwość można jednak przesłonić z wiersza polecenia przy użyciu jednej z poniższych metod.

    • Przy użyciu interfejsu wiersza polecenia platformy .NET Core:

      dotnet publish /p:Configuration=Release /p:PublishProfile=FolderProfile

      dotnet build -c Release /p:DeployOnBuild=true /p:PublishProfile=FolderProfile

    • Korzystanie z programu MSBuild:

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

Publikowanie w punkcie końcowym narzędzia MSDeploy z poziomu wiersza polecenia

W poniższym przykładzie użyto aplikacji internetowej ASP.NET Core utworzonej przez program Visual Studio o nazwie AzureWebApp. Profil publikowania aplikacja systemu Azure jest dodawany za pomocą programu Visual Studio. Aby uzyskać więcej informacji na temat tworzenia profilu, zobacz sekcję Publikowanie profilów .

Aby wdrożyć aplikację przy użyciu profilu publikowania, wykonaj msbuild polecenie w wierszu polecenia dla deweloperów programu Visual Studio. Wiersz polecenia jest dostępny w folderze programu Visual Studio menu Start na pasku zadań systemu Windows. Aby ułatwić dostęp, możesz dodać wiersz polecenia do menu Narzędzia w programie Visual Studio. Aby uzyskać więcej informacji, zobacz Developer Command Prompt for Visual Studio (Wiersz polecenia dla deweloperów dla programu Visual Studio).

Program MSBuild używa następującej składni polecenia:

msbuild {PATH} 
    /p:DeployOnBuild=true 
    /p:PublishProfile={PROFILE} 
    /p:Username={USERNAME} 
    /p:Password={PASSWORD}
  • {PATH}: ścieżka do pliku projektu aplikacji.
  • {PROFILE}: nazwa profilu publikowania.
  • {USERNAME}: nazwa użytkownika msDeploy. Element {USERNAME} można znaleźć w profilu publikowania.
  • {PASSWORD}: hasło MSDeploy. Uzyskaj element {PASSWORD} z witryny {PROFILE}. Opublikuj plik Ustawienia. Pobierz plik . Opublikuj plik Ustawienia z dowolnego z następujących:
    • Eksplorator rozwiązań: wybierz pozycję Wyświetl>Eksplorator chmury. Połączenie z subskrypcją platformy Azure. Otwórz usługę App Services. Kliknij prawym przyciskiem myszy aplikację. Wybierz pozycję Pobierz profil publikowania.
    • Witryna Azure Portal: wybierz pozycję Pobierz profil publikowania w panelu Przegląd aplikacji internetowej.

W poniższym przykładzie użyto profilu publikowania o nazwie AzureWebApp — Web Deploy:

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

Profil publikowania może być również używany z poleceniem dotnet msbuild interfejsu wiersza polecenia platformy .NET Core w powłoce poleceń systemu Windows:

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

Ważne

Polecenie dotnet msbuild to wieloplatformowe polecenie i może kompilować aplikacje ASP.NET Core w systemach macOS i Linux. Jednak program MSBuild w systemach macOS i Linux nie może wdrożyć aplikacji na platformie Azure lub w innych punktach końcowych narzędzia MSDeploy.

Ustawianie środowiska

Uwzględnij <EnvironmentName> właściwość w profilu publikowania (.pubxml) lub pliku projektu, aby ustawić środowisko aplikacji:

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

Jeśli potrzebujesz przekształceń web.config (na przykład ustawiania zmiennych środowiskowych na podstawie konfiguracji, profilu lub środowiska), zobacz Przekształcanie pliku web.config.

Wykluczanie plików

Podczas publikowania aplikacji internetowych platformy ASP.NET Core są uwzględniane następujące zasoby:

  • Tworzenie artefaktów
  • Foldery i pliki pasujące do następujących wzorców symboli globbingowych:
    • **\*.config (na przykład web.config)
    • **\*.json (na przykład appsettings.json)
    • wwwroot\**

Program MSBuild obsługuje wzorce globbingu. Na przykład następujący <Content> element pomija kopiowanie plików tekstowych (txt) w folderze wwwroot\content i jego podfolderach:

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

Powyższy znacznik można dodać do profilu publikowania .csproj lub pliku. Po dodaniu do .csproj pliku reguła zostanie dodana do wszystkich profilów publikowania w projekcie.

<MsDeploySkipRules> Poniższy element wyklucza wszystkie pliki z folderu wwwroot\content:

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

<MsDeploySkipRules> Nie spowoduje usunięcia elementów docelowych pomijania z lokacji wdrożenia. <Content> docelowe pliki i foldery są usuwane z lokacji wdrożenia. Załóżmy na przykład, że wdrożona aplikacja internetowa ma następujące pliki:

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

Jeśli zostaną dodane następujące <MsDeploySkipRules> elementy, te pliki nie zostaną usunięte w lokacji wdrożenia.

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

<MsDeploySkipRules> Poprzednie elementy uniemożliwiają wdrażanie pominiętych plików. Nie spowoduje to usunięcia tych plików po ich wdrożeniu.

<Content> Następujący element usuwa pliki docelowe w lokacji wdrożenia:

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

Użycie wdrożenia wiersza polecenia z poprzednim <Content> elementem daje odmianę następujących danych wyjściowych:

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

Pliki dołączane

W poniższych sekcjach opisano różne podejścia do dołączania plików w czasie publikowania. Sekcja Ogólne dołączania plików używa DotNetPublishFiles elementu, który jest udostępniany przez plik obiektów docelowych publikowania w zestawie SDK sieci Web. Sekcja Selektywne dołączanie plików używa ResolvedFileToPublish elementu, który jest udostępniany przez plik obiektów docelowych publikowania w zestawie SDK platformy .NET Core. Zestaw SDK sieci Web zależy od zestawu SDK platformy .NET Core, dlatego każdy element może być używany w projekcie ASP.NET Core.

Ogólne dołączanie plików

Poniższy przykładowy <ItemGroup> element demonstruje kopiowanie folderu znajdującego się poza katalogiem projektu do folderu opublikowanej witryny. Wszystkie pliki dodane do poniższych znaczników <ItemGroup> są domyślnie dołączane.

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

Powyższy znacznik:

  • Można dodać do .csproj pliku lub profilu publikowania. Jeśli zostanie dodany do .csproj pliku, zostanie on uwzględniony w każdym profilu publikowania w projekcie.
  • _CustomFiles Deklaruje element do przechowywania plików pasujących Include do wzorca globbing atrybutu. Folder images , do których odwołuje się wzorzec, znajduje się poza katalogem projektu. Właściwość zarezerwowana o nazwie $(MSBuildProjectDirectory), jest rozpoznawana jako ścieżka bezwzględna pliku projektu.
  • Zawiera listę plików do DotNetPublishFiles elementu. Domyślnie element elementu <DestinationRelativePath> jest pusty. Wartość domyślna jest zastępowana w znacznikach i używa dobrze znanych metadanych elementów, takich jak %(RecursiveDir). Tekst wewnętrzny reprezentuje folder wwwroot/images opublikowanej witryny.

Selektywne dołączanie plików

Wyróżniony znacznik w poniższym przykładzie pokazuje:

  • Kopiowanie pliku znajdującego się poza projektem do folderu wwwroot opublikowanej witryny. Nazwa pliku ReadMe2.md jest zachowywana.
  • Wykluczanie folderu wwwroot\Content.
  • Wykluczanie 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>

W poprzednim przykładzie użyto ResolvedFileToPublish elementu, którego zachowaniem domyślnym jest zawsze skopiowanie plików podanych w atrybucie Include do opublikowanej witryny. Zastąpij domyślne zachowanie, dołączając element podrzędny z tekstem <CopyToPublishDirectory> wewnętrznym elementu Never lub PreserveNewest. Przykład:

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

Aby uzyskać więcej przykładów wdrożenia, zobacz plik README zestawu SDK sieci Web.

Uruchamianie elementu docelowego przed opublikowaniem lub po nim

Wbudowane BeforePublish obiekty docelowe i AfterPublish wykonują element docelowy przed lub po obiekcie docelowym publikowania. Dodaj następujące elementy do profilu publikowania w celu rejestrowania komunikatów konsoli zarówno przed, jak i po opublikowaniu:

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

Publikowanie na serwerze przy użyciu niezaufanego certyfikatu

<AllowUntrustedCertificate> Dodaj właściwość z wartością True do profilu publikowania:

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

Usługa Kudu

Aby wyświetlić pliki we wdrożeniu aplikacji internetowej usługi aplikacja systemu Azure Service, użyj usługi Kudu. scm Dołącz token do nazwy aplikacji internetowej. Przykład:

URL Wynik
http://mysite.azurewebsites.net/ Aplikacja internetowa
http://mysite.scm.azurewebsites.net/ Usługa Kudu

Wybierz element menu Konsola debugowania, aby wyświetlić, edytować, usunąć lub dodać pliki.

Dodatkowe zasoby