Visual Studio-publicatieprofielen (.pubxml) voor ASP.NET Core-app-implementatie

Door Sayed Abraham Hashimi en Rick Anderson

Dit document is gericht op het gebruik van Visual Studio 2022 of hoger om publicatieprofielen te maken en te gebruiken. De publicatieprofielen die zijn gemaakt met Visual Studio kunnen worden gebruikt met MSBuild en Visual Studio. Zie Een ASP.NET Core-app publiceren naar Azure met Visual Studio voor instructies over het publiceren naar Azure.

Voor de meest recente en gedetailleerde informatie over:

• Publiceren met Visual Studio, zie Overzicht van Visual Studio Publish
• MSBuild, zie MSBuild
• Publiceren met MSBuild, zie Microsoft.NET.Sdk.Publish

De dotnet new mvc opdracht produceert een projectbestand met het volgende hoofdniveau <Project-element>:

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

Het kenmerk van Sdk het voorgaande <Project> element importeert de MSBuild-eigenschappen en -doelen uit $(MSBuildSDKsPath)\Microsoft.NET.Sdk.Web\Sdk\Sdk.props en $(MSBuildSDKsPath)\Microsoft.NET.Sdk.Web\Sdk\Sdk.targets, respectievelijk. De standaardlocatie voor $(MSBuildSDKsPath) (met Visual Studio 2022) is de map%programfiles%\Microsoft Visual Studio\2022\Preview\MSBuild\Sdks .

Microsoft.NET.Sdk.Web (Web SDK) is afhankelijk van andere SDK's, waaronder Microsoft.NET.Sdk (.NET SDK) en Microsoft.NET.Sdk.Razor (Razor SDK). De MSBuild-eigenschappen en -doelen die aan elke afhankelijke SDK zijn gekoppeld, worden geïmporteerd. Publicatiedoelen importeren de juiste set doelen op basis van de gebruikte publicatiemethode.

Wanneer MSBuild of Visual Studio een project laadt, vinden de volgende acties op hoog niveau plaats:

• Build project
• Rekenbestanden om te publiceren
• Bestanden publiceren naar bestemming

Projectitems berekenen

Wanneer het project wordt geladen, worden de MSBuild-projectitems (bestanden) berekend. Het itemtype bepaalt hoe het bestand wordt verwerkt. Bestanden worden standaard .cs opgenomen in de Compile lijst met items. Bestanden in de Compile itemlijst worden gecompileerd.

De Content itemlijst bevat bestanden die naast de build-uitvoer worden gepubliceerd. Bestanden die overeenkomen met de patronen wwwroot\**en **\*.config**\*.json worden standaard opgenomen in de Content lijst met items. Het globbing-patroon komt bijvoorbeeld wwwroot\** overeen met alle bestanden in de wwwroot-map en de bijbehorende submappen.

Als u expliciet een bestand wilt toevoegen aan de publicatielijst, voegt u het bestand rechtstreeks toe aan het .csproj bestand, zoals wordt weergegeven in de sectie Bestanden opnemen.

Wanneer u de knop Publiceren selecteert in Visual Studio of wanneer u publiceert vanaf de opdrachtregel:

• De eigenschappen/items worden berekend (de bestanden die nodig zijn om te bouwen).
• Alleen Visual Studio: NuGet-pakketten worden hersteld. (Herstellen moet expliciet zijn door de gebruiker in de CLI.)
• Het project bouwt.
• De publicatie-items worden berekend (de bestanden die nodig zijn om te publiceren).
• Het project wordt gepubliceerd (de berekende bestanden worden gekopieerd naar het publicatiedoel).

Wanneer een ASP.NET Core-project verwijst Microsoft.NET.Sdk.Web naar het projectbestand, wordt een app_offline.htm bestand in de hoofdmap van de map van de web-app geplaatst. Wanneer het bestand aanwezig is, wordt de app door de ASP.NET Core-module correct afgesloten en wordt het app_offline.htm bestand tijdens de implementatie verwerkt. Zie de referentie voor de configuratie van de ASP.NET Core Module voor meer informatie.

Eenvoudige opdrachtregelpublicatie

Opdrachtregelpublicatie werkt op alle . Door NET ondersteunde platforms en hiervoor is Visual Studio niet vereist. In de volgende voorbeelden wordt de opdracht dotnet publish van de .NET CLI uitgevoerd vanuit de projectmap (die het .csproj bestand bevat). Als de projectmap niet de huidige werkmap is, geeft u expliciet het pad naar het projectbestand door. For example:

dotnet publish C:\Webs\Web1

Voer de volgende opdrachten uit om een web-app te maken en te publiceren:

dotnet new mvc
dotnet publish

De dotnet publish opdracht produceert een variatie van de volgende uitvoer:

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

De standaardindeling van de publicatiemap is bin\Debug\{TARGET FRAMEWORK MONIKER}. Bijvoorbeeld bin\Release\net9.0\

Met de volgende opdracht geeft u een Release build en de publicatiemap op:

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

De dotnet publish opdracht roept MSBuild aan, die de Publish doel aanroept. Parameters die worden doorgegeven aan dotnet publish worden doorgegeven aan MSBuild. De parameters -c en -o worden respectievelijk toegewezen aan de eigenschappen van MSBuild Configuration en OutputPath.

MSBuild-eigenschappen kunnen worden doorgegeven met een van de volgende indelingen:

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

Met de volgende opdracht wordt bijvoorbeeld een Release build gepubliceerd naar een netwerkshare. De netwerkshare wordt opgegeven met slashes (r8/) en werkt op alle ondersteunde .NET-platforms.

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

Controleer of de gepubliceerde app voor implementatie niet wordt uitgevoerd. Bestanden in de publicatiemap worden vergrendeld wanneer de app wordt uitgevoerd. Implementatie kan niet worden uitgevoerd omdat vergrendelde bestanden niet kunnen worden gekopieerd.

Zie het leesmij-bestand Microsoft.NET.Sdk.Publish voor meer informatie.

Publish profiles

In deze sectie wordt Visual Studio 2022 of hoger gebruikt om een publicatieprofiel te maken. Zodra het profiel is gemaakt, is publiceren vanuit Visual Studio of de opdrachtregel beschikbaar. Publicatieprofielen kunnen het publicatieproces vereenvoudigen en er kan een willekeurig aantal profielen bestaan.

Maak een publicatieprofiel in Visual Studio door een van de volgende paden te kiezen:

• Klik met de rechtermuisknop op het project in Solution Explorer en selecteer Publiceren.
• Selecteer {PROJECT NAME} publiceren in het menu Build .

Het tabblad Publiceren van de pagina met app-mogelijkheden wordt weergegeven. Er zijn verschillende publicatiedoelen beschikbaar, waaronder:

• Azure
• Docker Container Registry
• Folder
• IIS, FTP, Web Deploy (voor elke webserver)
• Import Profile

Als u het meest geschikte publicatiedoel wilt bepalen, raadpleegt u welke publicatieopties geschikt zijn voor mij.

Wanneer het publicatiedoel map is geselecteerd, geeft u een mappad op om de gepubliceerde assets op te slaan. Het standaardmappad is bin\{PROJECT CONFIGURATION}\{TARGET FRAMEWORK MONIKER}\publish\. Bijvoorbeeld bin\Release\netcoreapp2.2\publish\. Selecteer de knop Profiel maken om te voltooien.

Zodra een publicatieprofiel is gemaakt, wordt de inhoud van het tabblad Publiceren gewijzigd. Het zojuist gemaakte profiel wordt weergegeven in een vervolgkeuzelijst. Selecteer onder de vervolgkeuzelijst Een nieuw profiel maken om nog een nieuw profiel te maken.

Het publicatieprogramma van Visual Studio produceert een Properties/PublishProfiles/{PROFILE NAME}.pubxml MSBuild-bestand met een beschrijving van het publicatieprofiel. Het .pubxml-bestand :

• Bevat configuratie-instellingen voor publiceren en wordt gebruikt door het publicatieproces.
• Kan worden gewijzigd om het build- en publicatieproces aan te passen.

Wanneer u publiceert naar een Azure-doel, wordt het .pubxml-bestand :

• Bevat de Azure-abonnements-id.
• Moet niet worden ingecheckt bij broncodebeheer omdat de abonnements-id gevoelige informatie is.

Gevoelige informatie, bijvoorbeeld het publicatiewachtwoord, wordt versleuteld op gebruikers-/computerniveau. Het Properties/PublishProfiles/{PROFILE NAME}.pubxml.user bestand bevat de informatie die MSBuild nodig heeft om de gebruikersnaam en het wachtwoord op te halen.

Zie Host en implementeer ASP.NET Core voor een overzicht van het publiceren van een ASP.NET Core-web-app. De MSBuild-taken en -doelen die nodig zijn om een ASP.NET Core-web-app te publiceren, zijn opensource in de dotnet/websdk-opslagplaats.

dotnet publish en dotnet build:

• Kan profielen voor mappen, MSDeploy en Kudu gebruiken. Omdat MSDeploy geen platformoverschrijdende ondersteuning biedt, worden MSDeploy-opties alleen ondersteund in Windows.
• Ondersteuning voor Kudu-API's om vanaf elk platform naar Azure te publiceren. Visual Studio publish ondersteunt de Kudu-API's, maar het wordt ondersteund door WebSDK voor platformoverschrijdende publicatie naar Azure.

Geef de dotnet publish opdracht niet doorDeployOnBuild.

Zie Microsoft.NET.Sdk.Publish voor meer informatie.

Voorbeeld van het publiceren van mappen

Wanneer u publiceert met een profiel met de naam FolderProfile, gebruikt u een van de volgende opdrachten:

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

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

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

De dotnet-buildopdrachtoproepenmsbuild van de .NET CLI om het build- en publicatieproces uit te voeren. De dotnet build opdrachten en msbuild opdrachten zijn gelijkwaardig bij het doorgeven van een mapprofiel. Wanneer u rechtstreeks in Windows aanroept msbuild , wordt de .NET Framework-versie van MSBuild gebruikt. Een niet-mapprofiel aanroepen dotnet build :

• Roept aan msbuild, die MSDeploy gebruikt.
• Resulteert in een fout (zelfs wanneer windows wordt uitgevoerd). Als u wilt publiceren met een profiel zonder map, roept u rechtstreeks aan msbuild .

Het volgende publicatieprofiel voor mappen is gemaakt met Visual Studio en wordt gepubliceerd naar een netwerkshare:

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

In het voorgaande voorbeeld:

• De <ExcludeApp_Data> eigenschap is aanwezig om te voldoen aan een XML-schemavereiste. De <ExcludeApp_Data> eigenschap heeft geen effect op het publicatieproces, zelfs als er een App_Data map in de hoofdmap van het project staat. De map App_Data ontvangt geen speciale behandeling, zoals in ASP.NET 4.x-projecten.
• De eigenschap <LastUsedBuildConfiguration> is ingesteld op Release. Wanneer u vanuit Visual Studio publiceert, wordt de waarde ingesteld met behulp van <LastUsedBuildConfiguration> de waarde wanneer het publicatieproces wordt gestart. <LastUsedBuildConfiguration> is speciaal en mag niet worden overschreven in een geïmporteerd MSBuild-bestand. Deze eigenschap kan echter worden overschreven vanaf de opdrachtregel met behulp van een van de volgende methoden.

  • De .NET CLI gebruiken:

    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
    

Publiceren naar een MSDeploy-eindpunt vanaf de opdrachtregel

See Microsoft.NET.Sdk.Publish.

De omgeving instellen

Neem de <EnvironmentName> eigenschap op in het publicatieprofiel (.pubxml) of het projectbestand om de omgeving van de app in te stellen:

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

Zie Transformeren web.configals u web.config transformaties nodig hebt (bijvoorbeeld omgevingsvariabelen instellen op basis van de configuratie, het profiel of de omgeving).

Exclude files

Bij het publiceren van ASP.NET Core-web-apps zijn de volgende assets opgenomen:

• Build artifacts
• Mappen en bestanden die overeenkomen met de volgende globbing-patronen:
  • **\*.config (bijvoorbeeld web.config)
  • **\*.json (bijvoorbeeld, appsettings.json)
  • wwwroot\**

MSBuild ondersteunt globbing-patronen. Het volgende <Content> element onderdrukt bijvoorbeeld het kopiëren van tekstbestanden (.txt) in de map wwwroot\content en de bijbehorende submappen:

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

De voorgaande markeringen kunnen worden toegevoegd aan een publicatieprofiel of het .csproj bestand. Wanneer deze wordt toegevoegd aan het .csproj bestand, wordt de regel toegevoegd aan alle publicatieprofielen in het project.

Met het volgende <MsDeploySkipRules> element worden alle bestanden uitgesloten van de map wwwroot\content :

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

<MsDeploySkipRules> verwijdert de overslaande doelen niet van de implementatiesite. <Content> doelbestanden en mappen worden verwijderd van de implementatiesite. Stel dat een geïmplementeerde web-app de volgende bestanden had:

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

Als de volgende <MsDeploySkipRules> elementen worden toegevoegd, worden deze bestanden niet verwijderd op de implementatiesite.

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

Met de voorgaande <MsDeploySkipRules> elementen voorkomt u dat de overgeslagen bestanden worden geïmplementeerd. Deze bestanden worden niet verwijderd zodra ze zijn geïmplementeerd.

Met het volgende <Content> element worden de doelbestanden op de implementatiesite verwijderd:

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

Het gebruik van opdrachtregelimplementatie met het voorgaande <Content> element resulteert in een variatie van de volgende uitvoer:

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

In de volgende secties worden verschillende benaderingen beschreven voor het opnemen van bestanden tijdens de publicatie. De sectie Algemene bestandsopname maakt gebruik van het DotNetPublishFiles item, dat wordt geleverd door een publicatiedoelenbestand in de web-SDK. De sectie Selectief opnemen van bestanden maakt gebruik van het ResolvedFileToPublish item, dat wordt geleverd door een publicatiedoelenbestand in de .NET SDK. Omdat de web-SDK afhankelijk is van de .NET SDK, kan elk item worden gebruikt in een ASP.NET Core-project.

Algemene bestandsopname

Het element van <ItemGroup> het volgende voorbeeld laat zien hoe u een map buiten de projectmap kopieert naar een map van de gepubliceerde site. Alle bestanden die aan de volgende markeringen <ItemGroup> worden toegevoegd, worden standaard opgenomen.

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

De voorgaande markeringen:

• Kan worden toegevoegd aan het .csproj bestand of het publicatieprofiel. Als het is toegevoegd aan het .csproj bestand, wordt het opgenomen in elk publicatieprofiel in het project.
• Declareert een _CustomFiles item voor het opslaan van bestanden die overeenkomen met het globbing-patroon van het Include kenmerk. De afbeeldingenmap waarnaar in het patroon wordt verwezen, bevindt zich buiten de projectmap. Een gereserveerde eigenschap, met de naam $(MSBuildProjectDirectory), wordt omgezet in het absolute pad van het projectbestand.
• Bevat een lijst met bestanden voor het DotNetPublishFiles item. Het element van <DestinationRelativePath> het item is standaard leeg. De standaardwaarde wordt overschreven in de markering en maakt gebruik van bekende metagegevens van items , zoals %(RecursiveDir). De binnenste tekst vertegenwoordigt de map wwwroot/images van de gepubliceerde site.

Selectief insluiten van bestanden

De gemarkeerde markeringen in het volgende voorbeeld laten zien:

• Een bestand dat zich buiten het project bevindt, naar de wwwroot-map van de gepubliceerde site kopiëren. De bestandsnaam van ReadMe2.md wordt onderhouden.
• Exclusief de map wwwroot\Content .
• Exclusief 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>
      <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>

In het voorgaande voorbeeld wordt het ResolvedFileToPublish item gebruikt, waarvan het standaardgedrag is om altijd de bestanden in het Include kenmerk naar de gepubliceerde site te kopiëren. Overschrijf het standaardgedrag door een <CopyToPublishDirectory> onderliggend element met binnenste tekst van of NeverPreserveNewest. For example:

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

Zie het README-bestand van de Web SDK voor meer voorbeelden van implementaties.

Een doel uitvoeren vóór of na publicatie

De ingebouwde BeforePublish doelen voeren AfterPublish een doel uit vóór of na het publicatiedoel. Voeg de volgende elementen toe aan het publicatieprofiel voor logboekconsoleberichten, zowel vóór als na publicatie:

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

Publiceren naar een server met behulp van een niet-vertrouwd certificaat

Voeg de <AllowUntrustedCertificate> eigenschap toe met een waarde van True het publicatieprofiel:

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

De Kudu-service

Gebruik de Kudu-service om de bestanden in een Azure App Service-web-app-implementatie weer te geven. Voeg het scm token toe aan de naam van de web-app. For example:

Selecteer het menu-item Foutopsporingsconsole om bestanden weer te geven, te bewerken, te verwijderen of toe te voegen.

Additional resources

• Leesmij-bestand voor web-SDK
• GitHub-opslagplaats voor web-SDK: problemen met bestanden en aanvraagfuncties voor implementatie.
• Web Deploy (MSDeploy) vereenvoudigt de implementatie van web-apps en websites op IIS-servers.
• Transform web.config