Visual Studio publikování profilů (.pubxml) pro ASP.NET Core nasazení aplikací

Sayed Ibrahim Hashimi a Rick Anderson

Tento dokument se zaměřuje na vytváření a Visual Studio profilů publikování pomocí verze 2019 nebo novější. Profily publikování vytvořené pomocí Visual Studio lze použít s MSBuild a Visual Studio. Pokyny k publikování do Azure najdete v tématu Publikování ASP.NET Core aplikace do Azure pomocí Visual Studio .

Příkaz dotnet new mvc vytvoří soubor projektu obsahující následující element na kořenové <Project> úrovni:

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

Atribut předchozího elementu importuje vlastnosti a cíle MSBuild z <Project> Sdk $(MSBuildSDKsPath)\technologie Microsoft .NET.Sdk.Web\Sdk\Sdk.props a $(MSBuildSDKsPath)\technologie Microsoft .NET.Sdk.Web\Sdk\Sdk.targets. Výchozí umístění pro $(MSBuildSDKsPath) (s Visual Studio 2019 Enterprise) je složka %programfiles(x86)%\Microsoft Visual Studio\2019\Enterprise\MSBuild\Sdks.

Microsoft.NET.Sdk.Web(Webová sada SDK) závisí na jiných sadách SDK, včetně ( .NET Core SDK ) a Microsoft.NET.Sdk ( Microsoft.NET.Sdk.Razor Razor SDK). Importuje MSBuild a cíle přidružené ke každé závislé sadě SDK. Cíle publikování importuje příslušnou sadu cílů na základě použité metody publikování.

Při MSBuild nebo Visual Studio projektu dojde k následujícím akcím vysoké úrovně:

• Sestavení projektu
• Výpočetní soubory k publikování
• Publikování souborů do cíle

Výpočetní položky projektu

Při načtení projektu se MSBuild položek projektu (souborů). Typ položky určuje způsob zpracování souboru. Ve výchozím nastavení jsou soubory .cs zahrnuty v Compile seznamu položek. Soubory v Compile seznamu položek se zkompilují.

Seznam Content položek obsahuje soubory, které jsou publikovány kromě výstupů sestavení. Ve výchozím nastavení jsou soubory odpovídající vzorům , a wwwroot\** **\*.config **\*.json zahrnuty v Content seznamu položek. Například vzor wwwroot\** zástupných názvů odpovídá všem souborům ve složce wwwroot a jejích podsložkách.

Pokud chcete soubor explicitně přidat do seznamu publikování, přidejte ho přímo do souboru .csproj, jak je znázorněno v části Zahrnout soubory.

Při výběru tlačítka Publikovat v Visual Studio nebo při publikování z příkazového řádku:

• Vypočítají se vlastnosti nebo položky (soubory, které jsou potřeba k sestavení).
• Visual Studio pouze: NuGet se obnoví balíčky. (Obnovení musí být explicitní uživatelem v rozhraní příkazového řádku.)
• Projekt se sestaví.
• Položky publikování se počítají (soubory, které jsou potřeba k publikování).
• Projekt se publikuje (vypočítané soubory se zkopírují do cíle publikování).

Když ASP.NET Core projekt odkazuje v souboru projektu, souborapp_offline.htmse umístí do kořenového adresáře Microsoft.NET.Sdk.Web adresáře webové aplikace. Když soubor existuje, modul ASP.NET Core aplikaci řádně vypne a během nasazováníapp_offline.htm dodá hlavní soubor. Další informace najdete v referenčních informacích ASP.NET Core Module.

Základní publikování z příkazového řádku

Publikování z příkazového řádku funguje na všech platformách podporovaných platformou .NET Core a nevyžaduje Visual Studio. V následujících příkladech se .NET Core CLI příkazu dotnet publish z adresáře projektu (který obsahuje soubor .csproj). Pokud složka projektu není aktuálním pracovním adresářem, explicitně předejte cestu k souboru projektu. Například:

dotnet publish C:\Webs\Web1

Spuštěním následujících příkazů vytvořte a publikujte webovou aplikaci:

dotnet new mvc
dotnet publish

Příkaz dotnet publish vytvoří variaci následujícího výstupu:

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\

Výchozí formát složky publikování je bin\Debug \ {TARGET \ FRAMEWORK MONIKER}\publish. Například bin\Debug\n\ etcoreapp2.2\publish.

Následující příkaz určuje sestavení a Release adresář publikování:

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

Příkaz dotnet publish volá MSBuild , která vyvolá Publish cíl. Všechny parametry předané dotnet publish do se předá MSBuild. Parametry -c -o a se mapovat MSBuild vlastnosti a Configuration OutputPath .

MSBuild vlastnosti lze předat pomocí jednoho z následujících formátů:

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

Například následující příkaz publikuje sestavení Release do sdílené síťové složky. Sdílená síťová sdílené složky se zadá s lomítky (//r8/) a funguje na všech podporovaných platformách .NET Core.

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

Ověřte, že publikovaná aplikace pro nasazení není spuštěná. Soubory ve složce publish jsou při spuštění aplikace uzamčené. K nasazení nemůže dojít, protože uzamčené soubory nelze zkopírovat.

Profily publikování

V této části Visual Studio profilu publikování verze 2019 nebo novější. Po vytvoření profilu je publikování z Visual Studio nebo z příkazového řádku k dispozici. Publikování profilů může zjednodušit proces publikování a může existovat libovolný počet profilů.

Vytvořte profil publikování v Visual Studio výběrem jedné z následujících cest:

• Klikněte pravým tlačítkem na projekt v Průzkumník řešení a vyberte Publikovat.
• V nabídce Sestavení vyberte Publikovat {NÁZEV PROJEKTU}.

Zobrazí se karta Publikovat na stránce možností aplikace. Pokud v projektu chybí profil publikování, zobrazí se stránka Vybrat cíl publikování. Budete vyzváni k výběru jednoho z následujících cílů publikování:

• Azure App Service
• Azure App Service v Linuxu
• Azure Virtual Machines
• Složka
• IIS, FTP, Nasazení webu (pro libovolný webový server)
• Import profilu

Nejvhodnější cíl publikování najdete v tématu Jaké možnosti publikování jsou pro mě nejvhodnější.

Když je vybraný cíl publikování složky, zadejte cestu ke složce, do které se mají publikované prostředky uložit. Výchozí cesta ke složce je bin \ {PROJECT CONFIGURATION} \ {TARGET FRAMEWORK MONIKER}\publish \. Například bin\Release\n\ etcoreapp2.2\publish. Dokončete výběrem tlačítka Vytvořit profil.

Po vytvoření profilu publikování se změní obsah karty Publikovat. Nově vytvořený profil se zobrazí v rozevíracím seznamu. Pod rozevíracím seznamem vyberte Vytvořit nový profil a vytvořte další nový profil.

Visual Studio publikování vytvoří soubor properties/publishprofiles/{NÁZEV PROFILU}.pubxml MSBuild který popisuje profil publikování. Soubor .pubxml:

• Obsahuje nastavení konfigurace publikování a využívá ho proces publikování.
• Je možné upravit a přizpůsobit proces sestavení a publikování.

Při publikování do cíle Azure obsahuje soubor .pubxml identifikátor vašeho předplatného Azure. U tohoto cílového typu se nedoporučuje přidávat tento soubor do správy zdrojového kódu. Při publikování do cíle mimo Azure je bezpečné zkontrolovat soubor .pubxml.

Citlivé informace (například heslo pro publikování) se šifrují na úrovni uživatele nebo počítače. Je uložený v souboru Properties/PublishProfiles/{NÁZEV PROFILU}.pubxml.user. Protože tento soubor může ukládat citlivé informace, neměl by se hlásil do správy zdrojového kódu.

Přehled publikování webové aplikace ASP.NET Core v tématu Hostování a nasazení ASP.NET Core . Úlohy MSBuild cíle potřebné k publikování webové aplikace ASP.NET Core jsou v úložišti dotnet/websdkopen source.

Následující příkazy mohou používat profily publikování folder, MSDeploy a Kudu. Vzhledem k tomu, že NÁSTROJ MSDeploy nemá podporu pro více platforem, podporují se následující možnosti MSDeploy pouze Windows.

Složka (funguje pro více platforem):

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>

Balíček MSDeploy:

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

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

V předchozích příkladech:

• dotnet publish a dotnet build podporují rozhraní API Kudu pro publikování do Azure z jakékoli platformy. publikování Visual Studio podporuje rozhraní api Kudu, ale podporuje je WebSDK pro publikování mezi platformami v Azure.
• Nepředávejte DeployOnBuild do dotnet publish příkazu.

Další informace najdete v tématu Microsoft. NET. SDK. Publish.

Přidejte profil publikování do složky vlastností projektu/PublishProfiles s následujícím obsahem:

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

Příklad publikování složky

Při publikování s profilem s názvem FolderProfile použijte libovolný z následujících příkazů:

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

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

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

Volání příkazu dotnet sestavení .NET Core CLI msbuild pro spuštění procesu sestavení a publikování. dotnet buildPříkazy a msbuild jsou ekvivalentní při předávání do profilu složky. při volání msbuild přímo na Windows se používá .NET Framework verze MSBuild. Volání dotnet build na profil mimo složku:

• Vyvolá msbuild , který používá MSDeploy.
• Výsledkem je selhání (i když běží na Windows). Chcete-li publikovat s profilem mimo složku, zavolejte msbuild přímo.

následující složka publikovat profil se vytvořila s Visual Studio a publikuje se do sdílené síťové složky:

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

V předchozím příkladu:

• <ExcludeApp_Data>Vlastnost je přítomna pouze pro splnění požadavku schématu XML. <ExcludeApp_Data>Vlastnost nemá žádný vliv na proces publikování, a to ani v případě, že je v kořenovém adresáři projektu App_Data složka. složka App_Data neobdrží zvláštní zacházení, protože funguje v projektech ASP.NET 4. x.
• Vlastnost <LastUsedBuildConfiguration> je nastavena na hodnotu Release. při publikování z Visual Studio je hodnota <LastUsedBuildConfiguration> nastavena pomocí hodnoty při spuštění procesu publikování. <LastUsedBuildConfiguration>má hodnotu special a v importovaném souboru MSBuild by se neměla přepsat. Tato vlastnost se ale dá přepsat z příkazového řádku pomocí jednoho z následujících přístupů.

  • Použití .NET Core CLI:

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

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

  • Použití MSBuild:

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

Publikování na koncový bod MSDeploy z příkazového řádku

v následujícím příkladu je použita webová aplikace ASP.NET Core vytvořená pomocí Visual Studio s názvem AzureWebApp. Profil publikování aplikací Azure se přidá s Visual Studio. Další informace o tom, jak vytvořit profil, najdete v části publikování profilů .

k nasazení aplikace pomocí profilu publikování spusťte msbuild příkaz z Visual Studio Developer Command Prompt. příkazový řádek je k dispozici ve složce Visual Studio nabídky Start na hlavním panelu Windows. Pro snazší přístup můžete přidat příkazový řádek do nabídky nástroje v Visual Studio. Další informace najdete v tématu Developer Command Prompt pro Visual Studio.

MSBuild používá následující syntaxi příkazu:

msbuild {PATH} 
    /p:DeployOnBuild=true 
    /p:PublishProfile={PROFILE} 
    /p:Username={USERNAME} 
    /p:Password={PASSWORD}

• {PATH}: Cesta k souboru projektu aplikace.
• {PROFILE}: Název publikačního profilu.
• {USERNAME}: Uživatelské jméno MSDeploy. Najdete {USERNAME} ho v profilu publikování.
• {PASSWORD}: Heslo MSDeploy Získat {PASSWORD} z {Profile} Soubor PublishSettings Stáhněte si . Soubor PublishSettings z některého z těchto:
  • Průzkumník řešení: vyberte Zobrazit > Průzkumníka cloudu. Připojení s vaším předplatným Azure. Otevřete App Services. Klikněte pravým tlačítkem na aplikaci. Vyberte Stáhnout profil publikování.
  • Azure Portal: na panelu přehledu webové aplikace vyberte získat profil publikování .

Následující příklad používá profil publikování s názvem AzureWebApp-nasazení webu:

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

profil publikování se dá použít taky s příkazem .NET Core CLI dotnet msbuild z příkazového prostředí Windows:

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

Nastavení prostředí

Zahrňte <EnvironmentName> vlastnost do profilu publikování (. pubxml) nebo soubor projektu pro nastavení prostředíaplikace:

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

Pokud vyžadujete web.config transformace (například nastavení proměnných prostředí na základě konfigurace, profilu nebo prostředí), přečtěte si téma Transformace souboru web.config .

Vyloučit soubory

při publikování ASP.NET Core web apps jsou k dispozici následující prostředky:

• Sestavit artefakty
• Složky a soubory, které odpovídají následujícím vzorům pro expanzi názvů:
  • **\*.config (například web.config)
  • **\*.json (například appsettings.json )
  • wwwroot\**

MSBuild podporuje vzory expanze. Například následující <Content> prvek potlačí kopírování textových (.txt) souborů ve složce wwwroot\content a jejích podsložkách:

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

Předchozí kód lze přidat do publikačního profilu nebo souboru . csproj . Po přidání do souboru . csproj je pravidlo přidáno do všech profilů publikování v projektu.

Následující <MsDeploySkipRules> prvek vyloučí všechny soubory ze složky wwwroot\content :

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

<MsDeploySkipRules> neodstraní cíle přeskočení z webu nasazení. <Content> cílové soubory a složky se odstraní z lokality nasazení. Předpokládejme například, že nasazená webová aplikace obsahovala následující soubory:

• Zobrazení/ Home /About1.cshtml
• Zobrazení/ Home /About2.cshtml
• Zobrazení/ Home /About3.cshtml

Pokud <MsDeploySkipRules> jsou přidány následující prvky, tyto soubory nebyly odstraněny na webu nasazení.

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

Předchozí <MsDeploySkipRules> prvky zabraňují nasazení vynechaných souborů. Po nasazení tyto soubory neodstraní.

Následující <Content> element odstraní cílové soubory v lokalitě nasazení:

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

Použití nasazení příkazového řádku s předchozím <Content> elementem vrací variaci následujícího výstupu:

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

Soubory k zahrnutí

Následující oddíly popisují různé přístupy k zařazení souborů v době publikování. Oddíl Obecné zahrnutí souborů používá DotNetPublishFiles položku, která je poskytována souborem cílů publikování v sadě Web SDK. Oddíl zahrnutí selektivních souborů používá ResolvedFileToPublish položku, která je k dispozici v souboru cílů publikování v .NET Core SDK. vzhledem k tomu, že webová sada SDK závisí na .NET Core SDK, může být každá položka použita v projektu ASP.NET Core.

Obecné zahrnutí souborů

Následující příklad <ItemGroup> elementu ukazuje zkopírování složky nacházející se mimo adresář projektu do složky publikovaného webu. Ve výchozím nastavení jsou zahrnuty všechny soubory přidané do následujících značek <ItemGroup> .

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

Předchozí kód:

• Lze přidat do souboru . csproj nebo do profilu publikování. Pokud je přidán do souboru . csproj , je zahrnut do každého profilu publikování v projektu.
• Deklaruje _CustomFiles položku pro ukládání souborů, které odpovídají Include vzoru rozexpanzení atributu. Složka imagí , na kterou se odkazuje ve vzoru, je umístěna mimo adresář projektu. Vyhrazená vlastnosts názvem $(MSBuildProjectDirectory) se překládá na absolutní cestu souboru projektu.
• Poskytuje seznam souborů k DotNetPublishFiles položce. Ve výchozím nastavení <DestinationRelativePath> je element položky prázdný. Výchozí hodnota je přepsána ve značce a používá dobře známá metadata položky , jako je například %(RecursiveDir) . Vnitřní text představuje složku wwwroot/image publikovaného webu.

Zahrnutí selektivních souborů

Zvýrazněný kód ukazuje následující příklad:

• Kopírování souboru, který se nachází mimo projekt, do složky wwwroot publikované lokality. Název souboru ReadMe2.MD se zachová.
• Vyloučení složky wwwroot\Content
• Vyloučení zobrazení : :: No – Loc (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>

Předchozí příklad používá ResolvedFileToPublish položku, jejíž výchozí chování je vždy kopírovat soubory, které jsou zadány v Include atributu do publikované lokality. Přepište výchozí chování zahrnutím <CopyToPublishDirectory> podřízeného prvku s vnitřním textem buď Never nebo PreserveNewest . Například:

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

Další ukázky nasazení najdete v souboru Readme pro web SDK.

Spustit cíl před nebo po publikování

Předdefinované BeforePublish a AfterPublish cíle provádějí cíl před nebo po cíli publikování. Přidejte následující prvky do profilu publikování pro protokolování zpráv konzoly před i po publikování:

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

Publikování na serveru pomocí nedůvěryhodného certifikátu

Přidejte <AllowUntrustedCertificate> vlastnost s hodnotou True do profilu publikování:

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

Služba Kudu

Pokud chcete zobrazit soubory ve Azure App Service nasazení webové aplikace, použijte službu Kudu. Přidejte scm token do názvu webové aplikace. Například:

Vyberte položku nabídky konzoly ladění pro zobrazení, úpravy, odstranění nebo přidání souborů.

Další zdroje informací

• Nasazení webu (MSDeploy) zjednodušuje nasazení webových aplikací a webů na servery služby IIS.
• sada Web SDK GitHub úložiště: problémy se soubory a žádosti pro nasazení.
• Transformace souboru web.config