Profili di pubblicazione di Visual Studio (con estensione pubxml) per la distribuzione di app ASP.NET CoreVisual Studio publish profiles (.pubxml) for ASP.NET Core app deployment

Di Sayed Ibrahim Hashimi e Rick AndersonBy Sayed Ibrahim Hashimi and Rick Anderson

Questo documento descrive come usare Visual Studio 2019 o versioni successive per la creazione e l'uso di profili di pubblicazione.This document focuses on using Visual Studio 2019 or later to create and use publish profiles. I profili di pubblicazione creati con Visual Studio possono essere usati con MSBuild e Visual Studio.The publish profiles created with Visual Studio can be used with MSBuild and Visual Studio. Per istruzioni sulla pubblicazione in Azure, vedere Pubblicare un'app ASP.NET Core in Azure con Visual Studio.For instructions on publishing to Azure, see Pubblicare un'app ASP.NET Core in Azure con Visual Studio.

Il comando dotnet new mvc genera un file di progetto che contiene l'elemento <Project> di primo livello seguente:The dotnet new mvc command produces a project file containing the following root-level <Project> element:

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

L'attributo Sdk dell'elemento <Project> 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.The preceding <Project> element's Sdk attribute imports the MSBuild properties and targets from $(MSBuildSDKsPath)\Microsoft.NET.Sdk.Web\Sdk\Sdk.props and $(MSBuildSDKsPath)\Microsoft.NET.Sdk.Web\Sdk\Sdk.targets, respectively. Il percorso predefinito per $(MSBuildSDKsPath) (con Visual Studio 2019 Enterprise) è la cartella %programfiles(x86)%\Microsoft Visual Studio\2019\Enterprise\MSBuild\Sdks.The default location for $(MSBuildSDKsPath) (with Visual Studio 2019 Enterprise) is the %programfiles(x86)%\Microsoft Visual Studio\2019\Enterprise\MSBuild\Sdks folder.

Microsoft.NET.Sdk.Web (Web SDK) dipende da altri SDK, tra cui Microsoft.NET.Sdk (.NET Core SDK) e Microsoft.NET.Sdk.Razor (Razor SDK).Microsoft.NET.Sdk.Web (Web SDK) depends on other SDKs, including Microsoft.NET.Sdk (.NET Core SDK) and Microsoft.NET.Sdk.Razor (Razor SDK). Vengono importate le proprietà e le destinazioni di MSBuild associate a ogni SDK dipendente.The MSBuild properties and targets associated with each dependent SDK are imported. Le destinazioni di pubblicazione importano il set appropriato di destinazioni in base al metodo di pubblicazione usato.Publish targets import the appropriate set of targets based on the publish method used.

Quando MSBuild o Visual Studio carica un progetto, vengono eseguite le azioni di alto livello seguenti:When MSBuild or Visual Studio loads a project, the following high-level actions occur:

  • Compilare un progettoBuild project
  • Calcolare i file da pubblicareCompute files to publish
  • Pubblicare i file nella destinazionePublish files to destination

Calcolare gli elementi del progettoCompute project items

Quando viene caricato il progetto, vengono calcolati gli elementi del progetto di MSBuild (file).When the project is loaded, the MSBuild project items (files) are computed. Il tipo di elemento determina la modalità di elaborazione del file.The item type determines how the file is processed. Per impostazione predefinita, i file cs sono inclusi nell'elenco di elementi Compile.By default, .cs files are included in the Compile item list. I file presenti nell'elenco di elementi Compile vengono compilati.Files in the Compile item list are compiled.

L'elenco di elementi Content contiene i file che sono pubblicati in aggiunta agli output di compilazione.The Content item list contains files that are published in addition to the build outputs. Per impostazione predefinita, i file corrispondenti ai criteri wwwroot\**, **\*.config e **\*.json vengono inclusi nell'elenco di elementi Content.By default, files matching the patterns wwwroot\**, **\*.config, and **\*.json are included in the Content item list. Il criterio GLOB wwwroot\**, ad esempio, specifica tutti i file nella cartella wwwroot e relative sottocartelle.For example, the wwwroot\** globbing pattern matches all files in the wwwroot folder and its subfolders.

Web SDK importa Razor SDK.The Web SDK imports the Razor SDK. Di conseguenza, anche i file corrispondenti ai criteri **\*.cshtml e **\*.razor vengono inclusi nell'elenco di elementi Content.As a result, files matching the patterns **\*.cshtml and **\*.razor are also included in the Content item list.

Web SDK importa Razor SDK.The Web SDK imports the Razor SDK. Di conseguenza, anche i file corrispondenti al criterio **\*.cshtml vengono inclusi nell'elenco di elementi Content.As a result, files matching the **\*.cshtml pattern are also included in the Content item list.

Per aggiungere esplicitamente un file all'elenco di pubblicazione, aggiungere il file direttamente nel file con estensione csproj, come illustrato nella sezione File di inclusione.To explicitly add a file to the publish list, add the file directly in the .csproj file as shown in the Include Files section.

Quando si seleziona il pulsante Pubblica in Visual Studio o quando si pubblica dalla riga di comando:When selecting the Publish button in Visual Studio or when publishing from the command line:

  • Vengono calcolati le proprietà/gli elementi (i file necessari per compilare).The properties/items are computed (the files that are needed to build).
  • Solo Visual Studio: i pacchetti NuGet vengono ripristinati.Visual Studio only: NuGet packages are restored. (Il ripristino deve essere esplicito da parte dell'utente nell'interfaccia della riga di comando.)(Restore needs to be explicit by the user on the CLI.)
  • Il progetto viene compilato.The project builds.
  • Vengono calcolati gli elementi di pubblicazione (i file necessari per pubblicare).The publish items are computed (the files that are needed to publish).
  • Il progetto viene pubblicato (i file calcolati vengono copiati nella destinazione di pubblicazione).The project is published (the computed files are copied to the publish destination).

Quando un progetto ASP.NET Core fa riferimento a Microsoft.NET.Sdk.Web nel file di progetto, nella radice della directory dell'app Web viene posizionato un file app_offline.htm.When an ASP.NET Core project references Microsoft.NET.Sdk.Web in the project file, an app_offline.htm file is placed at the root of the web app directory. Quando il file è presente, il modulo ASP.NET Core arresta normalmente l'app e rende disponibile il file app_offline.htm durante la distribuzione.When the file is present, the ASP.NET Core Module gracefully shuts down the app and serves the app_offline.htm file during the deployment. Per altre informazioni, vedere la Guida di riferimento per la configurazione del modulo ASP.NET Core.For more information, see the ASP.NET Core Module configuration reference.

Pubblicazione di base dalla riga di comandoBasic command-line publishing

La pubblicazione dalla riga di comando funziona su tutte le piattaforme supportate da .NET Core e non richiede Visual Studio.Command-line publishing works on all .NET Core-supported platforms and doesn't require Visual Studio. Negli esempi seguenti il comando dotnet publish dell'interfaccia della riga di comando di .NET Core viene eseguito dalla directory del progetto (che contiene il file con estensione csproj).In the following examples, the .NET Core CLI's dotnet publish command is run from the project directory (which contains the .csproj file). Se la cartella del progetto non è la directory di lavoro corrente, passare in modo esplicito il percorso del file di progetto.If the project folder isn't the current working directory, explicitly pass in the project file path. Esempio:For example:

dotnet publish C:\Webs\Web1

Eseguire i comandi seguenti per creare e pubblicare un'app Web:Run the following commands to create and publish a web app:

dotnet new mvc
dotnet publish

Il comando dotnet publish produce una variazione dell'output seguente:The dotnet publish command produces a variation of the following output:

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\

Il formato della cartella di pubblicazione predefinito è bin\Debug\{MONIKER FRAMEWORK DI DESTINAZIONE}\publish\ .The default publish folder format is bin\Debug\{TARGET FRAMEWORK MONIKER}\publish\. Ad esempio, bin\Debug\netcoreapp2.2\publish\ .For example, bin\Debug\netcoreapp2.2\publish\.

Il comando seguente specifica un build Release e la directory di pubblicazione:The following command specifies a Release build and the publishing directory:

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

Il comando dotnet publish chiama MSBuild che richiama la destinazione Publish.The dotnet publish command calls MSBuild, which invokes the Publish target. Tutti i parametri passati a dotnet publish vengono passati a MSBuild.Any parameters passed to dotnet publish are passed to MSBuild. I parametri -c e -o sono mappati rispettivamente alle proprietà Configuration e OutputPath di MSBuild.The -c and -o parameters map to MSBuild's Configuration and OutputPath properties, respectively.

È possibile passare le proprietà di MSBuild usando uno dei formati seguenti:MSBuild properties can be passed using either of the following formats:

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

Ad esempio, il comando seguente pubblica una build Release in una condivisione di rete.For example, the following command publishes a Release build to a network share. La condivisione di rete è specificata con le barre ( //r8/ ) e funziona su tutte le piattaforme .NET Core supportate.The network share is specified with forward slashes (//r8/) and works on all .NET Core supported platforms.

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

Verificare che l'app pubblicata per la distribuzione non sia in esecuzione.Confirm that the published app for deployment isn't running. I file nella cartella publish sono bloccati durante l'esecuzione dell'app.Files in the publish folder are locked when the app is running. La distribuzione non viene eseguita perché non è possibile copiare i file bloccati.Deployment can't occur because locked files can't be copied.

Profili di pubblicazionePublish profiles

Questa sezione usa Visual Studio 2019 o versioni successive per creare un profilo di pubblicazione.This section uses Visual Studio 2019 or later to create a publishing profile. Dopo la creazione del profilo, la pubblicazione è disponibile da Visual Studio o dalla riga di comando.Once the profile is created, publishing from Visual Studio or the command line is available. I profili di pubblicazione possono semplificare il processo di pubblicazione e può essere presente un numero illimitato di profili.Publish profiles can simplify the publishing process, and any number of profiles can exist.

Creare un profilo di pubblicazione in Visual Studio scegliendo uno dei seguenti percorsi:Create a publish profile in Visual Studio by choosing one of the following paths:

  • Fare clic con il pulsante destro del mouse sul progetto in Esplora soluzioni e scegliere pubblica.Right-click the project in Solution Explorer and select Publish.
  • Selezionare Pubblica {NOME PROGETTO} dal menu Compila.Select Publish {PROJECT NAME} from the Build menu.

Verrà visualizzata la scheda Pubblica della pagina di capacità dell'app.The Publish tab of the app capabilities page is displayed. Se il progetto non ha un profilo di pubblicazione, viene visualizzata la pagina Selezionare una destinazione di pubblicazione.If the project lacks a publish profile, the Pick a publish target page is displayed. Viene richiesto di selezionare una delle destinazioni di pubblicazione seguenti:You're asked to select one of the following publish targets:

  • Servizio app di AzureAzure App Service
  • Servizio app di Azure in LinuxAzure App Service on Linux
  • Macchine virtuali di AzureAzure Virtual Machines
  • CartellaFolder
  • IIS, FTP, Distribuzione Web (per qualsiasi server Web)IIS, FTP, Web Deploy (for any web server)
  • Importa profiloImport Profile

Per determinare la destinazione di pubblicazione più appropriata, vedere Quali sono le opzioni di pubblicazione più adatte.To determine the most appropriate publish target, see What publishing options are right for me.

Quando è selezionata la destinazione di pubblicazione Cartella, specificare il percorso di una cartella in cui archiviare gli asset pubblicati.When the Folder publish target is selected, specify a folder path to store the published assets. Il percorso della cartella predefinita è bin\{CONFIGURAZIONE PROGETTO}\{MONIKER FRAMEWORK DI DESTINAZIONE}\publish\ .The default folder path is bin\{PROJECT CONFIGURATION}\{TARGET FRAMEWORK MONIKER}\publish\. Ad esempio, bin\Release\netcoreapp2.2\publish\ .For example, bin\Release\netcoreapp2.2\publish\. Selezionare il pulsante Crea profilo per terminare.Select the Create Profile button to finish.

Dopo aver creato un profilo di pubblicazione, il contenuto della scheda Pubblica cambia.Once a publish profile is created, the Publish tab's content changes. Il nuovo profilo creato viene visualizzato in un elenco a discesa.The newly created profile appears in a drop-down list. Sotto l'elenco a discesa selezionare Crea nuovo profilo per creare un altro nuovo profilo.Below the drop-down list, select Create new profile to create another new profile.

Lo strumento di pubblicazione di Visual Studio produce un file MSBuild Properties/PublishProfiles/{PROFILE NAME}.pubxml che descrive il profilo di pubblicazione.Visual Studio's publish tool produces a Properties/PublishProfiles/{PROFILE NAME}.pubxml MSBuild file describing the publish profile. Il file con estensione pubxml:The .pubxml file:

  • Contiene le impostazioni di configurazione di pubblicazione e viene utilizzato dal processo di pubblicazione.Contains publish configuration settings and is consumed by the publishing process.
  • Può essere modificato per personalizzare il processo di compilazione e pubblicazione.Can be modified to customize the build and publish process.

Quando si esegue la pubblicazione in una destinazione di Azure, il file .pubxml contiene l'identificatore della sottoscrizione Azure.When publishing to an Azure target, the .pubxml file contains your Azure subscription identifier. Con tale tipo di destinazione, è sconsigliato aggiungere questo file al controllo del codice sorgente.With that target type, adding this file to source control is discouraged. Quando si pubblica in una destinazione non Azure, è possibile archiviare il file .pubxml.When publishing to a non-Azure target, it's safe to check in the .pubxml file.

Le informazioni riservate, come la password di pubblicazione, vengono crittografate a livello di singolo utente/computer.Sensitive information (like the publish password) is encrypted on a per user/machine level. Sono memorizzate nel file Properties/PublishProfiles/{NOME PROFILO}.pubxml.user.It's stored in the Properties/PublishProfiles/{PROFILE NAME}.pubxml.user file. Poiché questo file può contenere informazioni riservate, non deve essere archiviato nel controllo del codice sorgente.Because this file can store sensitive information, it shouldn't be checked into source control.

Per una panoramica su come pubblicare un'app Web ASP.NET Core, vedere Hosting e distribuzione di ASP.NET Core.For an overview of how to publish an ASP.NET Core web app, see Hosting e distribuzione di ASP.NET Core. Le attività e le destinazioni di MSBuild necessarie per pubblicare un'app Web ASP.NET Core sono open source nel repository ASPNET/WebSDK.The MSBuild tasks and targets necessary to publish an ASP.NET Core web app are open-source in the aspnet/websdk repository.

I comandi seguenti possono usare i profili di pubblicazione cartella, MSDeploy e Kudu .The following commands can use folder, MSDeploy, and Kudu publish profiles. Dato che MSDeploy non include il supporto multipiattaforma, le opzioni seguenti di MSDeploy sono supportate solo in Windows.Because MSDeploy lacks cross-platform support, the following MSDeploy options are supported only on Windows.

Cartella (multipiattaforma):Folder (works cross-platform):

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

MSDeploy:MSDeploy:

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

Pacchetto MSDeploy:MSDeploy package:

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

Negli esempi precedenti:In the preceding examples:

  • dotnet publish e dotnet build supportano le API Kudu per la pubblicazione in Azure da qualsiasi piattaforma.dotnet publish and dotnet build support Kudu APIs to publish to Azure from any platform. La pubblicazione con Visual Studio supporta le API Kudu, ma è supportata da WebSDK per la pubblicazione multipiattaforma in Azure.Visual Studio publish supports the Kudu APIs, but it's supported by WebSDK for cross-platform publish to Azure.
  • Non passare DeployOnBuild al comando dotnet publish.Don't pass DeployOnBuild to the dotnet publish command.

Per altre informazioni, vedere Microsoft.NET.Sdk.Publish.For more information, see Microsoft.NET.Sdk.Publish.

Aggiungere un profilo di pubblicazione alla cartella Properties/PublishProfiles del progetto con il contenuto seguente:Add a publish profile to the project's Properties/PublishProfiles folder with the following content:

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

Esempio di pubblicazione cartellaFolder publish example

Quando si esegue la pubblicazione con un profilo denominato FolderProfile, usare uno dei comandi seguenti:When publishing with a profile named FolderProfile, use either of the following commands:

  • 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 Core chiama msbuild per eseguire il processo di compilazione e pubblicazione.The .NET Core CLI's dotnet build command calls msbuild to run the build and publish process. I comandi dotnet build e msbuild sono equivalenti quando si passa un profilo di cartella.The dotnet build and msbuild commands are equivalent when passing in a folder profile. Chiamando msbuild direttamente in Windows, viene usata la versione .NET Framework di MSBuild.When calling msbuild directly on Windows, the .NET Framework version of MSBuild is used. La chiamata di dotnet build su un profilo non di tipo cartella:Calling dotnet build on a non-folder profile:

  • Richiama msbuild, che usa MSDeploy.Invokes msbuild, which uses MSDeploy.
  • Genera un errore (anche se in esecuzione in Windows).Results in a failure (even when running on Windows). Per la pubblicazione con un profilo non di tipo cartella, chiamare msbuild direttamente.To publish with a non-folder profile, call msbuild directly.

Il profilo di pubblicazione cartella seguente è stato creato con Visual Studio ed esegue la pubblicazione in una condivisione di rete:The following folder publish profile was created with Visual Studio and publishes to a network share:

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

Nell'esempio precedente:In the preceding example:

  • La proprietà <ExcludeApp_Data> è presente solo per soddisfare un requisito di XML Schema.The <ExcludeApp_Data> property is present merely to satisfy an XML schema requirement. La proprietà <ExcludeApp_Data> non ha alcun effetto sul processo di pubblicazione, anche se è presente una cartella App_Data nella radice del progetto.The <ExcludeApp_Data> property has no effect on the publish process, even if there's an App_Data folder in the project root. La cartella App_Data non riceve un trattamento speciale, come accade per i progetti ASP.NET 4.x.The App_Data folder doesn't receive special treatment as it does in ASP.NET 4.x projects.
  • La proprietà <LastUsedBuildConfiguration> è impostata su Release.The <LastUsedBuildConfiguration> property is set to Release. Nella pubblicazione da Visual Studio, il valore di <LastUsedBuildConfiguration> viene impostato usando il valore, quando viene avviato il processo di pubblicazione.When publishing from Visual Studio, the value of <LastUsedBuildConfiguration> is set using the value when the publish process is started. <LastUsedBuildConfiguration> è speciale e non deve essere sottoposta a override in un file di MSBuild importato.<LastUsedBuildConfiguration> is special and shouldn't be overridden in an imported MSBuild file. Questa proprietà, tuttavia, può essere sottoposta a override dalla riga di comando usando uno degli approcci seguenti.This property can, however, be overridden from the command line using one of the following approaches.

    • Mediante l'interfaccia della riga di comando di .NET Core:Using the .NET Core CLI:

      dotnet build -c Release /p:DeployOnBuild=true /p:PublishProfile=FolderProfile
      
    • Mediante MSBuild:Using MSBuild:

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

    Per altre informazioni, vedere MSBuild: how to set the configuration property (MSBuild: come impostare la proprietà di configurazione).For more information, see MSBuild: how to set the configuration property.

Pubblicare in un endpoint di MSDeploy dalla riga di comandoPublish to an MSDeploy endpoint from the command line

L'esempio seguente usa un'app Web ASP.NET Core creata da Visual Studio e denominata AzureWebApp.The following example uses an ASP.NET Core web app created by Visual Studio named AzureWebApp. Un profilo di pubblicazione app di Azure viene aggiunto con Visual Studio.An Azure Apps publish profile is added with Visual Studio. Per altre informazioni su come creare un profilo, vedere la sezione Profili di pubblicazione.For more information on how to create a profile, see the Publish profiles section.

Per distribuire l'app usando un profilo di pubblicazione, eseguire il comando msbuild dal prompt dei comandi per gli sviluppatori di Visual Studio.To deploy the app using a publish profile, execute the msbuild command from a Visual Studio Developer Command Prompt. Il prompt dei comandi è disponibile nella cartella Visual Studio del menu Start della barra delle applicazioni di Windows.The command prompt is available in the Visual Studio folder of the Start menu on the Windows taskbar. Per semplificare l'accesso, è possibile aggiungere il prompt dei comandi al menu Strumenti di Visual Studio.For easier access, you can add the command prompt to the Tools menu in Visual Studio. Per altre informazioni, vedere Prompt dei comandi per gli sviluppatori per Visual Studio.For more information, see Developer Command Prompt for Visual Studio.

MSBuild usa la sintassi dei comandi seguente:MSBuild uses the following command syntax:

msbuild {PATH} 
    /p:DeployOnBuild=true 
    /p:PublishProfile={PROFILE} 
    /p:Username={USERNAME} 
    /p:Password={PASSWORD}
  • {PERCORSO} – Percorso del file di progetto dell'app.{PATH} – Path to the app's project file.
  • {PROFILO} – Nome del profilo di pubblicazione.{PROFILE} – Name of the publish profile.
  • {NOMEUTENTE} – Nome utente MSDeploy.{USERNAME} – MSDeploy username. {NOMEUTENTE} è disponibile nel profilo di pubblicazione.The {USERNAME} can be found in the publish profile.
  • {PASSWORD} – Password di MSDeploy.{PASSWORD} – MSDeploy password. Il valore {PASSWORD} è disponibile nel file {PROFILO}.PublishSettings.Obtain the {PASSWORD} from the {PROFILE}.PublishSettings file. Scaricare il file .PublishSettings da:Download the .PublishSettings file from either:
    • Esplora soluzioni: selezionare Visualizza > Cloud Explorer.Solution Explorer: Select View > Cloud Explorer. Connettersi alla sottoscrizione di Azure.Connect with your Azure subscription. Aprire Servizi app.Open App Services. Fare clic con il pulsante destro del mouse sull'app.Right-click the app. Selezionare Scarica profilo di pubblicazione.Select Download Publish Profile.
    • Portale di Azure: selezionare Ottieni profilo di pubblicazione nel pannello Panoramica dell'app Web.Azure portal: Select Get publish profile in the web app's Overview panel.

L'esempio seguente usa un profilo di pubblicazione denominato AzureWebApp - Web Deploy:The following example uses a publish profile named AzureWebApp - Web Deploy:

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

Un profilo di pubblicazione può essere usato anche con il comando dotnet msbuild dell'interfaccia della riga di comando di .NET Core da una shell comandi di Windows:A publish profile can also be used with the .NET Core CLI's dotnet msbuild command from a Windows command shell:

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

Importante

Il comando dotnet msbuild è multipiattaforma e consente di compilare app ASP.NET Core in macOS e Linux.The dotnet msbuild command is a cross-platform command and can compile ASP.NET Core apps on macOS and Linux. Tuttavia, MSBuild in macOS e Linux non è in grado di distribuire un'app in Azure o in altri endpoint MSDeploy.However, MSBuild on macOS and Linux isn't capable of deploying an app to Azure or other MSDeploy endpoints.

Impostare l'ambienteSet the environment

Includere la proprietà <EnvironmentName> nel profilo di pubblicazione ( .pubxml) o nel file di progetto per impostare l'ambiente dell'app:Include the <EnvironmentName> property in the publish profile (.pubxml) or project file to set the app's environment:

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

Se sono necessarie trasformazioni web.config (ad esempio, l'impostazione di variabili di ambiente in base a configurazione, profilo o ambiente), vedere Trasformare web.config.If you require web.config transformations (for example, setting environment variables based on the configuration, profile, or environment), see Trasformare web.config.

Escludere fileExclude files

Quando si pubblicano app Web ASP.NET Core vengono inclusi gli asset seguenti:When publishing ASP.NET Core web apps, the following assets are included:

  • Artefatti della compilazioneBuild artifacts
  • Cartelle e file corrispondenti ai criteri GLOB seguenti:Folders and files matching the following globbing patterns:
    • **\*.config (ad esempio, web.config)**\*.config (for example, web.config)
    • **\*.json (ad esempio, appsettings.json)**\*.json (for example, appsettings.json)
    • wwwroot\**

MSBuild supporta i criteri GLOB.MSBuild supports globbing patterns. Ad esempio, l'elemento <Content> seguente elimina la copia dei file di testo ( .txt) nella cartella wwwroot\content e nelle relative sottocartelle:For example, the following <Content> element suppresses the copying of text (.txt) files in the wwwroot\content folder and its subfolders:

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

Il markup precedente può essere aggiunto a un profilo di pubblicazione o al file .csproj.The preceding markup can be added to a publish profile or the .csproj file. Quando viene aggiunta al file .csproj, la regola viene aggiunta a tutti i profili di pubblicazione del progetto.When added to the .csproj file, the rule is added to all publish profiles in the project.

L'elemento <MsDeploySkipRules> seguente esclude tutti i file dalla cartella wwwroot\content:The following <MsDeploySkipRules> element excludes all files from the wwwroot\content folder:

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

<MsDeploySkipRules> non elimina le destinazioni da ignorare dal sito di distribuzione.<MsDeploySkipRules> won't delete the skip targets from the deployment site. Vengono eliminati dal sito di distribuzione i file e le cartelle di destinazione <Content>.<Content> targeted files and folders are deleted from the deployment site. Si supponga, ad esempio, che un'app Web distribuita contenga i file seguenti:For example, suppose a deployed web app had the following files:

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

Se si aggiungono gli elementi <MsDeploySkipRules> seguenti, questi file non vengono eliminati nel sito di distribuzione.If the following <MsDeploySkipRules> elements are added, those files wouldn't be deleted on the deployment site.

<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.The preceding <MsDeploySkipRules> elements prevent the skipped files from being deployed. Tali file non verranno eliminati una volta distribuiti.It won't delete those files once they're deployed.

L'elemento <Content> seguente elimina i file di destinazione sul sito di distribuzione:The following <Content> element deletes the targeted files at the deployment site:

<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:Using command-line deployment with the preceding <Content> element yields a variation of the following output:

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

File di inclusioneInclude files

Le sezioni seguenti illustrano approcci diversi per l'inclusione di file in fase di pubblicazione.The following sections outline different approaches for file inclusion at publish time. Nella sezione Inclusione di file generale viene usato l'elemento DotNetPublishFiles, fornito da un file di destinazioni di pubblicazione in Web SDK.The General file inclusion section uses the DotNetPublishFiles item, which is provided by a publish targets file in the Web SDK. Nella sezione Inclusione di file selettiva viene usato l'elemento ResolvedFileToPublish, fornito da un file di destinazioni di pubblicazione in .NET Core SDK.The Selective file inclusion section uses the ResolvedFileToPublish item, which is provided by a publish targets file in the .NET Core SDK. Dato che Web SDK dipende da .NET Core SDK, è possibile usare entrambi gli elementi in un progetto ASP.NET Core.Because the Web SDK depends on the .NET Core SDK, either item can be used in an ASP.NET Core project.

Inclusione di file generaleGeneral file inclusion

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.The following example's <ItemGroup> element demonstrates copying a folder located outside of the project directory to a folder of the published site. Eventuali file aggiunti a <ItemGroup> del markup seguente vengono inclusi per impostazione predefinita.Any files added to the following markup's <ItemGroup> are included by default.

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

Il markup precedente:The preceding markup:

  • Può essere aggiunto al file con estensione csproj o al profilo di pubblicazione.Can be added to the .csproj file or the publish profile. Se viene aggiunto al file .csproj, è incluso in ogni profilo di pubblicazione nel progetto.If it's added to the .csproj file, it's included in each publish profile in the project.
  • Dichiara un elemento _CustomFiles per archiviare i file corrispondenti ai criteri GLOB dell'attributo Include.Declares a _CustomFiles item to store files matching the Include attribute's globbing pattern. La cartella images a cui fa riferimento il modello si trova all'esterno della directory del progetto.The images folder referenced in the pattern is located outside of the project directory. Una proprietà riservata, denominata $(MSBuildProjectDirectory), viene risolta nel percorso assoluto del file di progetto.A reserved property, named $(MSBuildProjectDirectory), resolves to the project file's absolute path.
  • Fornisce un elenco di file all'elemento DotNetPublishFiles.Provides a list of files to the DotNetPublishFiles item. Per impostazione predefinita, l'elemento <DestinationRelativePath> dell'elemento è vuoto.By default, the item's <DestinationRelativePath> element is empty. Il valore predefinito è sottoposto a override nel markup e usa metadati degli elementi noti, ad esempio %(RecursiveDir).The default value is overridden in the markup and uses well-known item metadata such as %(RecursiveDir). Il testo interno rappresenta la cartella wwwroot/images del sito pubblicato.The inner text represents the wwwroot/images folder of the published site.

Inclusione di file selettivaSelective file inclusion

Il markup evidenziato nell'esempio seguente dimostra:The highlighted markup in the following example demonstrates:

  • La copia di un file che si trova all'esterno del progetto nella cartella wwwroot del sito pubblicato.Copying a file located outside of the project into the published site's wwwroot folder. Il nome del file ReadMe2.md viene mantenuto.The file name of ReadMe2.md is maintained.
  • L'esclusione della cartella wwwroot\Content.Excluding the wwwroot\Content folder.
  • L'esclusione di Views\Home\About2.cshtml.Excluding 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>

L'esempio precedente usa l'elemento ResolvedFileToPublish, il cui comportamento predefinito consiste nel copiare sempre i file specificati nell'attributo Include nel sito pubblicato.The preceding example uses the ResolvedFileToPublish item, whose default behavior is to always copy the files provided in the Include attribute to the published site. Eseguire l'override del comportamento predefinito, includendo un elemento figlio <CopyToPublishDirectory> con il testo interno Never o PreserveNewest.Override the default behavior by including a <CopyToPublishDirectory> child element with inner text of either Never or PreserveNewest. Esempio:For example:

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

Per altri esempi di distribuzione, vedere il file Leggimi del repository di Web SDK.For more deployment samples, see the Web SDK repository Readme.

Eseguire una destinazione prima o dopo la pubblicazioneRun a target before or after publishing

Le destinazioni incorporate BeforePublish e AfterPublish consentono di eseguire una destinazione prima o dopo la destinazione di pubblicazione.The built-in BeforePublish and AfterPublish targets execute a target before or after the publish target. Aggiungere gli elementi seguenti al profilo di pubblicazione per registrare i messaggi della console prima e dopo la pubblicazione:Add the following elements to the publish profile to log console messages both before and after publishing:

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

Pubblicazione in un server tramite un certificato non attendibilePublish to a server using an untrusted certificate

Aggiungere la proprietà <AllowUntrustedCertificate> con un valore True al profilo di pubblicazione:Add the <AllowUntrustedCertificate> property with a value of True to the publish profile:

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

Servizio KuduThe Kudu service

Per visualizzare i file in una distribuzione di app Web di Servizio app di Azure, usare il servizio Kudu.To view the files in an Azure App Service web app deployment, use the Kudu service. Accodare il token scm al nome dell'app Web.Append the scm token to the web app name. Esempio:For example:

URLURL RisultatoResult
http://mysite.azurewebsites.net/ App WebWeb App
http://mysite.scm.azurewebsites.net/ Servizio KuduKudu service

Selezionare la voce di menu Console di debug per visualizzare, modificare, eliminare o aggiungere file.Select the Debug Console menu item to view, edit, delete, or add files.

Risorse aggiuntiveAdditional resources