Visual Studio publicerar profiler (.pubxml) för ASP.NET Core-appdistribution

Av Sayed Ibrahim Hashimi och Rick Anderson

Det här dokumentet fokuserar på att använda Visual Studio 2022 eller senare för att skapa och använda publiceringsprofiler. Publiceringsprofilerna som skapats med Visual Studio kan användas med MSBuild och Visual Studio. Anvisningar om hur du publicerar till Azure finns i Publicera en ASP.NET Core-app till Azure med Visual Studio.

För den mest aktuella och detaljerade informationen om:

• Publicera med Visual Studio finns i Översikt över Visual Studio Publish
• MSBuild, se MSBuild
• Publicera med MSBuild finns i Microsoft.NET.Sdk.Publish

Kommandot dotnet new mvc skapar en projektfil som innehåller följande projektelement> på rotnivå<:

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

Det föregående elementets Sdk attribut importerar <Project>MSBuild-egenskaperna och målen från $(MSBuildSDKsPath)\Microsoft.NET.Sdk.Web\Sdk\Sdk.props och $(MSBuildSDKsPath)\Microsoft.NET.Sdk.Web\Sdk\Sdk.targets. Standardplatsen för $(MSBuildSDKsPath) (med Visual Studio 2022) är mappen %programfiles%\Microsoft Visual Studio\2022\Preview\MSBuild\Sdks .

Microsoft.NET.Sdk.Web (Web SDK) är beroende av andra SDK:er, inklusive Microsoft.NET.Sdk (.NET SDK) och Microsoft.NET.Sdk.Razor (Razor SDK). MsBuild-egenskaperna och målen som är associerade med varje beroende SDK importeras. Publicera mål importerar lämplig uppsättning mål baserat på publiceringsmetoden som används.

När MSBuild eller Visual Studio läser in ett projekt utförs följande åtgärder på hög nivå:

• Build project
• Beräkna filer som ska publiceras
• Publicera filer till målet

Beräkna projektobjekt

När projektet läses in beräknas MSBuild-projektobjekten (filer). Objekttypen avgör hur filen bearbetas. Som standard .cs ingår filer i Compile objektlistan. Filer i Compile objektlistan kompileras.

Objektlistan Content innehåller filer som publiceras utöver kompileringsutdata. Som standard inkluderas filer som matchar mönstren wwwroot\**, **\*.configoch **\*.json i Content objektlistan. Mönstret globbing matchar till exempel wwwroot\** alla filer i mappen wwwroot och dess undermappar.

Om du uttryckligen vill lägga till en fil i publiceringslistan lägger du till filen direkt i .csproj filen enligt vad som visas i avsnittet Inkludera filer .

När du väljer knappen Publicera i Visual Studio eller när du publicerar från kommandoraden:

• Egenskaperna/objekten beräknas (de filer som behövs för att skapa).
• Endast Visual Studio: NuGet-paket återställs. (Återställningen måste vara explicit av användaren i CLI.)
• Projektet byggs.
• Publiceringsobjekten beräknas (de filer som behövs för att publicera).
• Projektet publiceras (de beräknade filerna kopieras till publiceringsmålet).

När ett ASP.NET Core-projekt refererar Microsoft.NET.Sdk.Web till i projektfilen placeras en app_offline.htm fil i roten i webbappkatalogen. När filen finns stänger ASP.NET Core-modulen appen och hanterar app_offline.htm filen under distributionen. Mer information finns i konfigurationsreferensen för ASP.NET Core Module.

Grundläggande kommandoradspublicering

Kommandoradspublicering fungerar på alla . PLATTFORMAR som stöds av NET och kräver inte Visual Studio. I följande exempel körs .NET CLI:s dotnet-publiceringskommando från projektkatalogen (som innehåller .csproj filen). Om projektmappen inte är den aktuella arbetskatalogen skickar du uttryckligen in projektfilens sökväg. For example:

dotnet publish C:\Webs\Web1

Kör följande kommandon för att skapa och publicera en webbapp:

dotnet new mvc
dotnet publish

Kommandot dotnet publish genererar en variant av följande utdata:

C:\Webs\Web1>dotnet publish
Restore complete (0.4s)
  Web1 succeeded (9.2s) → bin\Release\net9.0\publish\

Standardformatet för publiceringsmappen är bin\Debug\{TARGET FRAMEWORK MONIKER}. Till exempel: bin\Release\net9.0\

Följande kommando anger en Release version och publiceringskatalogen:

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

Kommandot dotnet publish anropar MSBuild, som anropar Publish-målet. Alla parametrar som skickas till dotnet publish skickas till MSBuild. Parametrarna -c och -o mappas till MSBuilds egenskaper för Configuration respektive OutputPath.

MSBuild-egenskaper kan skickas med något av följande format:

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

Följande kommando publicerar till exempel en Release version till en nätverksresurs. Nätverksresursen anges med snedstreck (r8/) och fungerar på alla .NET-plattformar som stöds.

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

Bekräfta att den publicerade appen för distribution inte körs. Filer i publiceringsmappen låses när appen körs. Det går inte att distribuera eftersom låsta filer inte kan kopieras.

Mer information finns i filen Microsoft.NET.Sdk.Publish readme.

Publish profiles

Det här avsnittet använder Visual Studio 2022 eller senare för att skapa en publiceringsprofil. När profilen har skapats är publicering från Visual Studio eller kommandoraden tillgänglig. Publiceringsprofiler kan förenkla publiceringsprocessen och valfritt antal profiler kan finnas.

Skapa en publiceringsprofil i Visual Studio genom att välja någon av följande sökvägar:

• Högerklicka på projektet i Solution Explorer och välj Publicera.
• Välj Publicera {PROJEKTNAMN} på menyn Skapa .

Fliken Publicera på sidan med appfunktioner visas. Det finns flera publiceringsmål, bland annat:

• Azure
• Docker Container Registry
• Folder
• IIS, FTP, Web Deploy (för alla webbservrar)
• Import Profile

Information om hur du fastställer det lämpligaste publiceringsmålet finns i Vilka publiceringsalternativ är rätt för mig.

När målet Mapppublicering har valts anger du en mappsökväg för att lagra de publicerade tillgångarna. Standardmappsökvägen är bin\{PROJECT CONFIGURATION}\{TARGET FRAMEWORK MONIKER}\publish\. Till exempel bin\Release\netcoreapp2.2\publish\. Välj knappen Skapa profil för att slutföra.

När en publiceringsprofil har skapats ändras innehållet på fliken Publicera . Den nyligen skapade profilen visas i en listruta. Under listrutan väljer du Skapa ny profil för att skapa en ny profil.

Visual Studios publiceringsverktyg skapar en Properties/PublishProfiles/{PROFILE NAME}.pubxml MSBuild-fil som beskriver publiceringsprofilen. .pubxml-filen:

• Innehåller publiceringskonfigurationsinställningar och används av publiceringsprocessen.
• Kan ändras för att anpassa bygg- och publiceringsprocessen.

När du publicerar till ett Azure-mål, .pubxml-filen :

• Innehåller Azure-prenumerationsidentifieraren.
• Bör inte checkas in i källkontrollen eftersom prenumerationsidentifieraren är känslig information.

Känslig information, till exempel publiceringslösenordet, krypteras på användar-/datornivå. Filen Properties/PublishProfiles/{PROFILE NAME}.pubxml.user innehåller den information som krävs av MSBuild för att hämta användarnamnet och lösenordet.

En översikt över hur du publicerar en ASP.NET Core-webbapp finns i Värd och distribuera ASP.NET Core. DE MSBuild-uppgifter och mål som krävs för att publicera en ASP.NET Core-webbapp är öppen källkod i dotnet/websdk-lagringsplatsen.

dotnet publish och dotnet build:

• Kan använda mapp-, MSDeploy- och Kudu-publiceringsprofiler. Eftersom MSDeploy saknar plattformsoberoende stöd stöds MSDeploy-alternativ endast i Windows.
• Stöd för Kudu-API:er för att publicera till Azure från valfri plattform. Visual Studio Publish stöder Kudu-API:er, men stöds av WebSDK för plattformsoberoende publicering till Azure.

Skicka DeployOnBuild inte till dotnet publish kommandot.

Mer information finns i Microsoft.NET.Sdk.Publish.

Exempel på mapppublicning

När du publicerar med en profil med namnet FolderProfileanvänder du något av följande kommandon:

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

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

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

.NET CLI:s dotnet build-kommando anropar msbuild för att köra bygg- och publiceringsprocessen. Kommandona dotnet build och msbuild är likvärdiga när du skickar in en mappprofil. När du anropar msbuild direkt i Windows används .NET Framework-versionen av MSBuild. Anropar dotnet build en profil som inte är mapp:

• Anropar msbuild, som använder MSDeploy.
• Resulterar i ett fel (även när det körs i Windows). Om du vill publicera med en profil som inte är mapp anropar du msbuild direkt.

Följande mapppublicerarprofil skapades med Visual Studio och publiceras till en nätverksresurs:

<?xml version="1.0" encoding="utf-8"?>
<!--
https://go.microsoft.com/fwlink/?LinkID=208121.
-->
<Project>
  <PropertyGroup>
    <DeleteExistingFiles>false</DeleteExistingFiles>
    <ExcludeApp_Data>false</ExcludeApp_Data>
    <LaunchSiteAfterPublish>true</LaunchSiteAfterPublish>
    <LastUsedBuildConfiguration>Release</LastUsedBuildConfiguration>
    <LastUsedPlatform>Any CPU</LastUsedPlatform>
    <PublishProvider>FileSystem</PublishProvider>
    <PublishUrl>\\r8\Release\AdminWeb</PublishUrl>
    <WebPublishMethod>FileSystem</WebPublishMethod>
    <_TargetId>Folder</_TargetId>
  </PropertyGroup>
</Project>

I föregående exempel:

• Egenskapen <ExcludeApp_Data> finns för att uppfylla ett XML-schemakrav. Egenskapen <ExcludeApp_Data> påverkar inte publiceringsprocessen, även om det finns en App_Data mapp i projektroten. Mappen App_Data får ingen särskild behandling som den gör i ASP.NET 4.x-projekt.
• Egenskapen <LastUsedBuildConfiguration> är inställd på Release. När du publicerar från Visual Studio anges värdet för med hjälp av <LastUsedBuildConfiguration> värdet när publiceringsprocessen startas. <LastUsedBuildConfiguration> är speciellt och bör inte åsidosättas i en importerad MSBuild-fil. Den här egenskapen kan dock åsidosättas från kommandoraden med någon av följande metoder.

  • Använda .NET CLI:

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

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

  • Using MSBuild:

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

Publicera till en MSDeploy-slutpunkt från kommandoraden

See Microsoft.NET.Sdk.Publish.

Ange miljön

<EnvironmentName> Inkludera egenskapen i publiceringsprofilen (.pubxml) eller projektfilen för att ange appens miljö:

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

Om du behöver web.config transformeringar (till exempel ställa in miljövariabler baserat på konfiguration, profil eller miljö) kan du läsa Transformera web.config.

Exclude files

När du publicerar ASP.NET Core-webbappar ingår följande tillgångar:

• Build artifacts
• Mappar och filer som matchar följande globbande mönster:
  • **\*.config (till exempel web.config)
  • **\*.json (till exempel appsettings.json)
  • wwwroot\**

MSBuild stöder globbningsmönster. Följande element förhindrar till exempel <Content> kopiering av textfiler (.txt) i mappen wwwroot\content och dess undermappar:

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

Föregående markering kan läggas till i en publiceringsprofil eller .csproj i filen. När den läggs till i .csproj filen läggs regeln till i alla publiceringsprofiler i projektet.

Följande <MsDeploySkipRules> element exkluderar alla filer från mappen wwwroot\content :

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

<MsDeploySkipRules> tar inte bort hoppa över mål från distributionsplatsen. <Content> riktade filer och mappar tas bort från distributionsplatsen. Anta till exempel att en distribuerad webbapp hade följande filer:

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

Om följande <MsDeploySkipRules> element läggs till skulle filerna inte tas bort på distributionsplatsen.

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

Föregående <MsDeploySkipRules> element förhindrar att de överhoppade filerna distribueras. De filerna tas inte bort när de har distribuerats.

Följande <Content> element tar bort målfilerna på distributionsplatsen:

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

Användning av kommandoradsdistribution med föregående <Content> element ger en variant av följande utdata:

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

Include files

I följande avsnitt beskrivs olika metoder för filinkludering vid publiceringstillfället. Avsnittet Allmän filinkludering använder DotNetPublishFiles objektet, som tillhandahålls av en publiceringsmålfil i Web SDK. Avsnittet Selektiv filinkludering använder ResolvedFileToPublish objektet, som tillhandahålls av en publiceringsmålfil i .NET SDK. Eftersom Web SDK är beroende av .NET SDK kan något av objekten användas i ett ASP.NET Core-projekt.

Allmän filinkludering

Följande exempelelement <ItemGroup> visar hur du kopierar en mapp utanför projektkatalogen till en mapp på den publicerade webbplatsen. Alla filer som läggs till i följande markering <ItemGroup> ingår som standard.

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

Föregående markering:

• Kan läggas till i .csproj filen eller publiceringsprofilen. Om den läggs till i filen ingår den .csproj i varje publiceringsprofil i projektet.
• Deklarerar ett _CustomFiles objekt för att lagra filer som matchar Include attributets globbande mönster. Avbildningsmappen som refereras till i mönstret finns utanför projektkatalogen. En reserverad egenskap med namnet $(MSBuildProjectDirectory), matchar projektfilens absoluta sökväg.
• Innehåller en lista över filer till DotNetPublishFiles objektet. Som standard är objektets <DestinationRelativePath> element tomt. Standardvärdet åsidosättas i markeringen och använder välkända objektmetadata som %(RecursiveDir). Den inre texten representerar mappen wwwroot/images på den publicerade webbplatsen.

Selektiv filinkludering

Den markerade markeringen i följande exempel visar:

• Kopiera en fil utanför projektet till den publicerade webbplatsens wwwroot-mapp . Filnamnet för ReadMe2.md underhålls.
• Exklusive mappen wwwroot\Content .
• Exklusive vyer\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>
      <GUID Here=""></GUID>
    </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>

I föregående exempel används ResolvedFileToPublish objektet, vars standardbeteende är att alltid kopiera filerna som anges i Include attributet till den publicerade webbplatsen. Åsidosätt standardbeteendet genom att inkludera ett <CopyToPublishDirectory> underordnat element med inre text i antingen Never eller PreserveNewest. For example:

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

Fler distributionsexempel finns i README-filen för Web SDK.

Kör ett mål före eller efter publicering

De inbyggda BeforePublish målen och AfterPublish målen kör ett mål före eller efter publiceringsmålet. Lägg till följande element i publiceringsprofilen för att logga konsolmeddelanden både före och efter publicering:

<?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. In order to learn more about this please visit https://go.microsoft.com/fwlink/?LinkID=208121. 
-->
<Project>
  <PropertyGroup>
    <WebPublishMethod>MSDeploy</WebPublishMethod>
    <ResourceId>/subscriptions/SomeGuid/resourcegroups/TP_RG/providers/Microsoft.Web/sites/TP22</ResourceId>
    <ResourceGroup>TP_RG</ResourceGroup>
    <PublishProvider>AzureWebSite</PublishProvider>
    <LastUsedBuildConfiguration>Release</LastUsedBuildConfiguration>
    <LastUsedPlatform>Any CPU</LastUsedPlatform>
    <SiteUrlToLaunchAfterPublish>https://tp22.azurewebsites.net</SiteUrlToLaunchAfterPublish>
    <LaunchSiteAfterPublish>true</LaunchSiteAfterPublish>
    <ExcludeApp_Data>false</ExcludeApp_Data>
    <ProjectGuid>GuidHere</ProjectGuid>
    <MSDeployServiceURL>something.scm.azurewebsites.net:443</MSDeployServiceURL>
    <DeployIisAppPath>myDeploysIISpath</DeployIisAppPath>
    <RemoteSitePhysicalPath />
    <SkipExtraFilesOnServer>true</SkipExtraFilesOnServer>
    <MSDeployPublishMethod>WMSVC</MSDeployPublishMethod>
    <EnableMSDeployBackup>true</EnableMSDeployBackup>
    <EnableMsDeployAppOffline>true</EnableMsDeployAppOffline>
    <UserName />
    <_SavePWD>false</_SavePWD>
    <_DestinationType>AzureWebSite</_DestinationType>
    <InstallAspNetCoreSiteExtension>false</InstallAspNetCoreSiteExtension>
  </PropertyGroup>
    <Target Name="CustomActionsBeforePublish" BeforeTargets="BeforePublish">
        <Message Text="Inside BeforePublish" Importance="high" />
    </Target>
    <Target Name="CustomActionsAfterPublish" AfterTargets="AfterPublish">
        <Message Text="Inside AfterPublish" Importance="high" />
    </Target>
</Project>

Publicera på en server med ett certifikat som inte är betrott

Lägg till egenskapen <AllowUntrustedCertificate> med värdet True i publiceringsprofilen:

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

Kudu-tjänsten

Om du vill visa filerna i en Azure App Service-webbappdistribution använder du Kudu-tjänsten. Lägg till token i scm webbappens namn. For example:

Välj menyalternativet Felsökningskonsol för att visa, redigera, ta bort eller lägga till filer.

Additional resources

• Web SDK README-fil
• GitHub-lagringsplats för Web SDK: Filproblem och begärandefunktioner för distribution.
• Webbdistribution (MSDeploy) förenklar distributionen av webbappar och webbplatser till IIS-servrar.
• Transform web.config