Profili di pubblicazione di Visual Studio (.pubxml) per la distribuzione di app ASP.NET Core

Di Sayed Ibrahim Hashimi e Rick Anderson

Questo documento è incentrato sull'uso di Visual Studio 2022 o versione successiva per creare e usare profili di pubblicazione. I profili di pubblicazione creati con Visual Studio possono essere usati con MSBuild e Visual Studio. Per istruzioni sulla pubblicazione in Azure, vedere Pubblicare un'app ASP.NET Core in Azure con Visual Studio.

Per informazioni più aggiornate e dettagliate su:

• Pubblicazione con Visual Studio, vedere Panoramica della pubblicazione di Visual Studio
• MSBuild, consultare MSBuild
• Pubblicazione con MSBuild, vedere Microsoft.NET.Sdk.Publish

Il dotnet new mvc comando genera un file di progetto contenente l'elemento<>radice seguente:

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

L'attributo <Project> dell'elemento Sdk precedente importa le proprietà e le destinazioni di MSBuild rispettivamente da $(MSBuildSDKsPath)\Microsoft.NET.Sdk.Web\Sdk\Sdk.props e $(MSBuildSDKsPath)\Microsoft.NET.Sdk.Web\Sdk\Sdk.targets. Il percorso predefinito per $(MSBuildSDKsPath) (con Visual Studio 2022) è la cartella %programfiles%\Microsoft Visual Studio\2022\Preview\MSBuild\Sdks .

Microsoft.NET.Sdk.Web (SDK Web) dipende da altri SDK, tra cui Microsoft.NET.Sdk (.NET SDK) e Microsoft.NET.Sdk.Razor (Razor SDK). Vengono importate le proprietà e le destinazioni di MSBuild associate a ogni SDK dipendente. Le destinazioni di pubblicazione importano il set appropriato di destinazioni in base al metodo di pubblicazione usato.

Quando MSBuild o Visual Studio carica un progetto, vengono eseguite le azioni di alto livello seguenti:

• Compila progetto
• Calcolare i file da pubblicare
• Pubblicare i file nella destinazione

Calcolare gli elementi del progetto

Quando viene caricato il progetto, vengono calcolati gli elementi del progetto di MSBuild (file). Il tipo di elemento determina la modalità di elaborazione del file. Per impostazione predefinita, .cs i file sono inclusi nell'elenco di Compile elementi. I file presenti nell'elenco di elementi Compile vengono compilati.

L'elenco di elementi Content contiene i file che sono pubblicati in aggiunta agli output di compilazione. Per impostazione predefinita, i file corrispondenti ai criteri wwwroot\**, **\*.config e **\*.json vengono inclusi nell'elenco di elementi Content. Ad esempio, il wwwroot\**modello globbing corrisponde a tutti i file nella cartella wwwroot e nelle relative sottocartelle.

Web SDK importa l'SDK.Razor Di conseguenza, anche i file corrispondenti ai criteri **\*.cshtml e **\*.razor vengono inclusi nell'elenco di elementi Content.

Per aggiungere in modo esplicito un file all'elenco di pubblicazione, aggiungere il file direttamente nel .csproj file, come illustrato nella sezione Includi file .

Quando si seleziona il pulsante Pubblica in Visual Studio o quando si pubblica dalla riga di comando:

• Vengono calcolati le proprietà/gli elementi (i file necessari per compilare).
• Solo Visual Studio: i pacchetti NuGet vengono ripristinati. (Il ripristino deve essere esplicito da parte dell'utente nell'interfaccia della riga di comando.)
• Il progetto viene compilato.
• Vengono calcolati gli elementi di pubblicazione (i file necessari per pubblicare).
• Il progetto viene pubblicato (i file calcolati vengono copiati nella destinazione di pubblicazione).

Quando un progetto ASP.NET Core fa Microsoft.NET.Sdk.Web riferimento al file di progetto, un app_offline.htm file viene inserito nella radice della directory dell'app Web. Quando il file è presente, il modulo ASP.NET Core arresta normalmente l'app e rende disponibile il file app_offline.htm durante la distribuzione. Per altre informazioni, vedere la Guida di riferimento per la configurazione del modulo ASP.NET Core.

Pubblicazione di base dalla riga di comando

La pubblicazione da riga di comando funziona su tutte le piattaforme supportate da .NET e non richiede Visual Studio. Negli esempi seguenti il comando dotnet publish dell'interfaccia della riga di comando di .NET viene eseguito dalla directory del progetto (che contiene il .csproj file). Se la cartella del progetto non è la directory di lavoro corrente, passare in modo esplicito il percorso del file di progetto. Per esempio:

dotnet publish C:\Webs\Web1

Eseguire i comandi seguenti per creare e pubblicare un'app Web:

dotnet new mvc
dotnet publish

Il comando dotnet publish produce una variazione dell'output seguente:

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

Il formato predefinito della cartella di pubblicazione è bin\Debug\{TARGET FRAMEWORK MONIKER}. Ad esempio, bin\Release\net9.0\

Il comando seguente specifica un build Release e la directory di pubblicazione:

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

Il comando dotnet publish chiama MSBuild che richiama la destinazione Publish. Tutti i parametri passati a dotnet publish vengono passati a MSBuild. I parametri -c e -o sono mappati rispettivamente alle proprietà Configuration e OutputPath di MSBuild.

Le proprietà di MSBuild possono essere passate usando uno dei formati seguenti:

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

Ad esempio, il comando seguente pubblica una build Release in una condivisione di rete. La condivisione di rete viene specificata con barre oblique (//r8/) e funziona su tutte le piattaforme supportate da .NET.

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

Verificare che l'app pubblicata per la distribuzione non sia in esecuzione. I file nella cartella publish sono bloccati durante l'esecuzione dell'app. La distribuzione non viene eseguita perché non è possibile copiare i file bloccati.

Per ulteriori informazioni, vedere il file README Microsoft.NET.Sdk.Publish.

Pubblicare profili

Questa sezione usa Visual Studio 2022 o versione successiva per creare un profilo di pubblicazione. Dopo la creazione del profilo, la pubblicazione è disponibile da Visual Studio o dalla riga di comando. I profili di pubblicazione possono semplificare il processo di pubblicazione e può essere presente un numero illimitato di profili.

Creare un profilo di pubblicazione in Visual Studio scegliendo uno dei seguenti percorsi:

• Fare clic con il pulsante destro del mouse in Esplora soluzioni, quindi scegliere Pubblica.
• Selezionare Pubblica {NOME PROGETTO}dal menu Compila.

Verrà visualizzata la scheda Pubblica della pagina di capacità dell'app. Sono disponibili diverse destinazioni di pubblicazione, tra cui:

• Azure
• Registro Contenitori Docker
• Folder
• IIS, FTP, Distribuzione Web (per qualsiasi server Web)
• Importa profilo

Per determinare la destinazione di pubblicazione più appropriata, vedere Quali sono le opzioni di pubblicazione più adatte.

Quando è selezionata la destinazione di pubblicazione Cartella, specificare il percorso di una cartella in cui archiviare gli asset pubblicati. Il percorso predefinito della cartella è bin\{PROJECT CONFIGURATION}\{TARGET FRAMEWORK MONIKER}\publish\. Ad esempio, bin\Release\netcoreapp2.2\publish\. Selezionare il pulsante Crea profilo per terminare.

Dopo aver creato un profilo di pubblicazione, il contenuto della scheda Pubblica cambia. Il nuovo profilo creato viene visualizzato in un elenco a discesa. Sotto l'elenco a discesa selezionare Crea nuovo profilo per creare un altro nuovo profilo.

Lo strumento di pubblicazione di Visual Studio produce un Properties/PublishProfiles/{PROFILE NAME}.pubxml file MSBuild che descrive il profilo di pubblicazione. Il file con estensione pubxml:

• Contiene le impostazioni di configurazione di pubblicazione e viene utilizzato dal processo di pubblicazione.
• Può essere modificato per personalizzare il processo di compilazione e pubblicazione.

Quando si pubblica su una destinazione Azure, il file .pubxml:

• Contiene l'identificatore della sottoscrizione di Azure.
• Non deve essere inserito nel controllo del codice sorgente perché l'identificatore della sottoscrizione è un'informazione sensibile.

Le informazioni riservate, ad esempio la password di pubblicazione, vengono crittografate a livello di utente/computer. Il Properties/PublishProfiles/{PROFILE NAME}.pubxml.user file contiene le informazioni necessarie da MSBuild per recuperare il nome utente e la password.

Per una panoramica su come pubblicare un'app Web ASP.NET Core, vedere Ospitare e distribuire ASP.NET Core. Le attività e le destinazioni di MSBuild necessarie per pubblicare un'app Web ASP.NET Core sono open source nel repository dotnet/websdk.

dotnet publish e dotnet build:

• Può usare profili di pubblicazione di cartella, MSDeploy e Kudu . Poiché MSDeploy non dispone del supporto multipiattaforma, le opzioni MSDeploy sono supportate solo in Windows.
• Supportare le API Kudu per la pubblicazione in Azure da qualsiasi piattaforma. La pubblicazione con Visual Studio supporta le API Kudu, ma è supportata da WebSDK per la pubblicazione multipiattaforma in Azure.

Non passare DeployOnBuild al dotnet publish comando.

Per altre informazioni, vedere Microsoft.NET.Sdk.Publish.

Esempio di pubblicazione di cartelle

Quando si pubblica con un profilo denominato FolderProfile, usare uno dei comandi seguenti:

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

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

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

Il comando dotnet build dell'interfaccia della riga di comando di .NET chiama msbuild per eseguire il processo di compilazione e pubblicazione. I comandi dotnet build e msbuild sono equivalenti quando si passa un profilo di cartella. Chiamando msbuild direttamente in Windows, viene usata la versione .NET Framework di MSBuild. La chiamata di dotnet build su un profilo non di tipo cartella:

• Richiama msbuild, che usa MSDeploy.
• Genera un errore (anche se in esecuzione in Windows). Per la pubblicazione con un profilo non di tipo cartella, chiamare msbuild direttamente.

Il profilo di pubblicazione cartella seguente è stato creato con Visual Studio ed esegue la pubblicazione in una condivisione di rete:

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

Nell'esempio precedente:

• La <ExcludeApp_Data> proprietà è presente per soddisfare un requisito di XML Schema. La proprietà <ExcludeApp_Data> non ha alcun effetto sul processo di pubblicazione, anche se è presente una cartella App_Data nella radice del progetto. La cartella App_Data non riceve un trattamento speciale, come accade per i progetti ASP.NET 4.x.
• La proprietà <LastUsedBuildConfiguration> è impostata su Release. Nella pubblicazione da Visual Studio, il valore di <LastUsedBuildConfiguration> viene impostato usando il valore, quando viene avviato il processo di pubblicazione. <LastUsedBuildConfiguration> è speciale e non deve essere sottoposta a override in un file di MSBuild importato. Questa proprietà, tuttavia, può essere sottoposta a override dalla riga di comando usando uno degli approcci seguenti.

  • Uso dell'interfaccia della riga di comando di .NET:

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

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

  • Uso di MSBuild:

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

Pubblicare in un endpoint di MSDeploy dalla riga di comando

Vedere Microsoft.NET.Sdk.Publish.

Impostare l'ambiente

Includere la proprietà <EnvironmentName> nel profilo di pubblicazione (.pubxml) o nel file di progetto per impostare l'ambiente dell'app:

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

Se sono necessarie trasformazioni web.config , ad esempio l'impostazione delle variabili di ambiente in base alla configurazione, al profilo o all'ambiente, vedere Trasformare web.config.

Escludere i file

Quando si pubblicano app Web ASP.NET Core vengono inclusi gli asset seguenti:

• Artefatti di compilazione
• Cartelle e file corrispondenti ai modelli di globing seguenti:
  • **\*.config (ad esempio, web.config)
  • **\*.json (ad esempio, appsettings.json)
  • wwwroot\**

MSBuild supporta i criteri GLOB. Ad esempio, l'elemento <Content> seguente elimina la copia dei file di testo (.txt) nella cartella wwwroot\content e nelle relative sottocartelle:

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

Il markup precedente può essere aggiunto a un profilo di pubblicazione o al .csproj file. Quando viene aggiunto al .csproj file, la regola viene aggiunta a tutti i profili di pubblicazione nel progetto.

L'elemento <MsDeploySkipRules> seguente esclude tutti i file dalla cartella wwwroot\content:

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

<MsDeploySkipRules> non elimina le destinazioni da ignorare dal sito di distribuzione. Vengono eliminati dal sito di distribuzione i file e le cartelle di destinazione <Content>. Si supponga, ad esempio, che un'app Web distribuita contenga i file seguenti:

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

Se si aggiungono gli elementi <MsDeploySkipRules> seguenti, questi file non vengono eliminati nel sito di distribuzione.

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

Gli elementi <MsDeploySkipRules> precedenti impediscono che i file ignorati vengano distribuiti. Tali file non verranno eliminati una volta distribuiti.

L'elemento <Content> seguente elimina i file di destinazione sul sito di distribuzione:

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

L'uso della distribuzione dalla riga di comando con l'elemento <Content> precedente produce una variante dell'output seguente:

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

Includi file

Le sezioni seguenti illustrano approcci diversi per l'inclusione di file in fase di pubblicazione. La sezione Inclusione file generale usa l'elemento DotNetPublishFiles , fornito da un file di destinazioni di pubblicazione in Web SDK. La sezione Inclusione file selettiva usa l'elemento ResolvedFileToPublish , fornito da un file di destinazioni di pubblicazione in .NET SDK. Poiché Web SDK dipende da .NET SDK, entrambi gli elementi possono essere usati in un progetto ASP.NET Core.

Inclusione di file generale

L'elemento <ItemGroup> dell'esempio seguente illustra la copia di una cartella che si trova all'esterno della directory di progetto in una cartella del sito pubblicato. Eventuali file aggiunti a <ItemGroup> del markup seguente vengono inclusi per impostazione predefinita.

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

Il markup precedente:

• Può essere aggiunto al .csproj file o al profilo di pubblicazione. Se viene aggiunto al .csproj file, viene incluso in ogni profilo di pubblicazione nel progetto.
• Dichiara un elemento _CustomFiles per archiviare i file corrispondenti ai criteri GLOB dell'attributo Include. La cartella images a cui fa riferimento il modello si trova all'esterno della directory del progetto. Una proprietà riservata, denominata $(MSBuildProjectDirectory), viene risolta nel percorso assoluto del file di progetto.
• Fornisce un elenco di file all'elemento DotNetPublishFiles. Per impostazione predefinita, l'elemento <DestinationRelativePath> dell'elemento è vuoto. Il valore predefinito è sottoposto a override nel markup e usa metadati degli elementi noti, ad esempio %(RecursiveDir). Il testo interno rappresenta la cartella wwwroot/images del sito pubblicato.

Inclusione di file selettiva

Il markup evidenziato nell'esempio seguente dimostra:

• La copia di un file che si trova all'esterno del progetto nella cartella wwwroot del sito pubblicato. Il nome del file ReadMe2.md viene mantenuto.
• L'esclusione della cartella wwwroot\Content.
• Esclusione di 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>

L'esempio precedente usa l'elemento ResolvedFileToPublish, il cui comportamento predefinito consiste nel copiare sempre i file specificati nell'attributo Include nel sito pubblicato. Eseguire l'override del comportamento predefinito, includendo un elemento figlio <CopyToPublishDirectory> con il testo interno Never o PreserveNewest. Per esempio:

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

Per altri esempi di distribuzione, vedere il file README dell'SDK Web.

Eseguire una destinazione prima o dopo la pubblicazione

Le destinazioni incorporate BeforePublish e AfterPublish consentono di eseguire una destinazione prima o dopo la destinazione di pubblicazione. Aggiungere gli elementi seguenti al profilo di pubblicazione per registrare i messaggi della console prima e dopo la pubblicazione:

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

Pubblicazione in un server tramite un certificato non attendibile

Aggiungere la proprietà <AllowUntrustedCertificate> con un valore True al profilo di pubblicazione:

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

Servizio Kudu

Per visualizzare i file in una distribuzione di app Web di Servizio app di Azure, usare il servizio Kudu. Accodare il token scm al nome dell'app Web. Per esempio:

URL	Result
http://mysite.azurewebsites.net/	App Web
http://mysite.scm.azurewebsites.net/	Servizio Kudu

Selezionare la voce di menu Console di debug per visualizzare, modificare, eliminare o aggiungere file.

Risorse aggiuntive

• File README dell'SDK Web
• Repository GitHub dell'SDK Web: problemi di file e funzionalità di richiesta per la distribuzione.
• Distribuzione Web (MSDeploy) semplifica la distribuzione di app Web e siti Web sui server IIS.
• Trasformare web.config