Profili di pubblicazione di Visual Studio per la distribuzione di app ASP.NET CoreVisual Studio publish profiles 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 2017 o versioni successive per la creazione e l'uso di profili di pubblicazione.This document focuses on using Visual Studio 2017 or later to create and use publish profiles. I profili di pubblicazione creati con Visual Studio possono essere eseguiti da MSBuild e Visual Studio.The publish profiles created with Visual Studio can be run from MSBuild and Visual Studio. Per istruzioni sulla pubblicazione in Azure, vedere Pubblicare un'app Web ASP.NET Core in Servizio app di Azure con Visual Studio.See Publish an ASP.NET Core web app to Azure App Service using Visual Studio for instructions on publishing to Azure.

Il file di progetto seguente è stato creato con il comando dotnet new mvc:The following project file was created with the command dotnet new mvc:

<Project Sdk="Microsoft.NET.Sdk.Web">

  <PropertyGroup>
    <TargetFramework>netcoreapp2.2</TargetFramework>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="Microsoft.AspNetCore.App" />
  </ItemGroup>

</Project>
<Project Sdk="Microsoft.NET.Sdk.Web">

  <PropertyGroup>
    <TargetFramework>netcoreapp2.1</TargetFramework>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="Microsoft.AspNetCore.App" />
  </ItemGroup>

</Project>

L'attributo Sdk dell'elemento <Project> esegue le attività seguenti:The <Project> element's Sdk attribute accomplishes the following tasks:

  • Importa il file delle proprietà da $(MSBuildSDKsPath)\Microsoft.NET.Sdk.Web\Sdk\Sdk.Props all'inizio.Imports the properties file from $(MSBuildSDKsPath)\Microsoft.NET.Sdk.Web\Sdk\Sdk.Props at the beginning.
  • Importa il file di destinazioni da $(MSBuildSDKsPath)\Microsoft.NET.Sdk.Web\Sdk\Sdk.targets alla fine.Imports the targets file from $(MSBuildSDKsPath)\Microsoft.NET.Sdk.Web\Sdk\Sdk.targets at the end.

Il percorso predefinito per MSBuildSDKsPath (con Visual Studio 2017 Enterprise) è la cartella %programfiles(x86)%\Microsoft Visual Studio\2017\Enterprise\MSBuild\Sdks.The default location for MSBuildSDKsPath (with Visual Studio 2017 Enterprise) is the %programfiles(x86)%\Microsoft Visual Studio\2017\Enterprise\MSBuild\Sdks folder.

L'SDK Microsoft.NET.Sdk.Web dipende da:The Microsoft.NET.Sdk.Web SDK depends on:

  • Microsoft.NET.Sdk.Web.ProjectSystemMicrosoft.NET.Sdk.Web.ProjectSystem
  • Microsoft.NET.Sdk.PublishMicrosoft.NET.Sdk.Publish

Che determina l'importazione delle proprietà e destinazioni seguenti:Which causes the following properties and targets to be imported:

  • $(MSBuildSDKsPath)\Microsoft.NET.Sdk.Web.ProjectSystem\Sdk\Sdk.Props$(MSBuildSDKsPath)\Microsoft.NET.Sdk.Web.ProjectSystem\Sdk\Sdk.Props
  • $(MSBuildSDKsPath)\Microsoft.NET.Sdk.Web.ProjectSystem\Sdk\Sdk.targets$(MSBuildSDKsPath)\Microsoft.NET.Sdk.Web.ProjectSystem\Sdk\Sdk.targets
  • $(MSBuildSDKsPath)\Microsoft.NET.Sdk.Publish\Sdk\Sdk.Props$(MSBuildSDKsPath)\Microsoft.NET.Sdk.Publish\Sdk\Sdk.Props
  • $(MSBuildSDKsPath)\Microsoft.NET.Sdk.Publish\Sdk\Sdk.targets$(MSBuildSDKsPath)\Microsoft.NET.Sdk.Publish\Sdk\Sdk.targets

Le destinazioni di pubblicazione importano il set corretto di destinazioni in base al metodo di pubblicazione usato.Publish targets import the right 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 (file).When the project is loaded, the project items (files) are computed. L'attributo item type determina la modalità di elaborazione del file.The item type attribute 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 al criterio wwwroot/** saranno inclusi nell'elemento Content.By default, files matching the pattern wwwroot/** are included in the Content item. Il criterio GLOB wwwroot/\*\* specifica tutti i file nella cartella wwwroot e relative sottocartelle.The wwwroot/\*\* globbing pattern matches all files in the wwwroot folder and subfolders. Per aggiungere esplicitamente un file all'elenco di pubblicazione, aggiungere il file direttamente nel file .csproj, come illustrato in File di inclusione.To explicitly add a file to the publish list, add the file directly in the .csproj file as shown in Include Files.

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 viene eseguito dalla directory del progetto (che contiene il file .csproj).In the samples below, the dotnet publish command is run from the project directory (which contains the .csproj file). Se non si è nella cartella del progetto, passare esplicitamente il percorso del file del progetto.If not in the project folder, explicitly pass in the project file path. Ad 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 genera un output analogo a quello illustrato di seguito:The dotnet publish command produces output similar to the following:

C:\Webs\Web1>dotnet publish
Microsoft (R) Build Engine version 15.3.409.57025 for .NET Core
Copyright (C) Microsoft Corporation. All rights reserved.

  Web1 -> C:\Webs\Web1\bin\Debug\netcoreapp{X.Y}\Web1.dll
  Web1 -> C:\Webs\Web1\bin\Debug\netcoreapp{X.Y}\publish\

La cartella di pubblicazione predefinita è bin\$(Configuration)\netcoreapp<version>\publish.The default publish folder is bin\$(Configuration)\netcoreapp<version>\publish. Il valore predefinito per $(Configuration) è Debug.The default for $(Configuration) is Debug. Nell'esempio precedente, <TargetFramework> è netcoreapp{X.Y}.In the preceding sample, the <TargetFramework> is netcoreapp{X.Y}.

dotnet publish -h visualizza informazioni della Guida per la pubblicazione.dotnet publish -h displays help information for 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. Il parametro -c esegue il mapping alla proprietà di MSBuild Configuration.The -c parameter maps to the Configuration MSBuild property. Il parametro -o esegue il mapping a OutputPath.The -o parameter maps to OutputPath.

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

Il comando seguente pubblica un build Release a una condivisione di rete:The following command publishes a Release build to a network share:

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

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.

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 2017 o versioni successive per creare un profilo di pubblicazione.This section uses Visual Studio 2017 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:

  • In Esplora soluzioni fare clic con il pulsante destro del mouse sul progetto e selezionare 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 capacities page is displayed. Se il progetto non dispone di un profilo di pubblicazione, viene visualizzata la pagina seguente:If the project lacks a publish profile, the following page is displayed:

Scheda Pubblica della pagina di capacità dell'app

Quando è selezionata l'opzione Cartella, specificare il percorso di una cartella in cui archiviare gli asset pubblicati.When Folder is selected, specify a folder path to store the published assets. La cartella predefinita è bin\Release\PublishOutput.The default folder is bin\Release\PublishOutput. Fare clic sul pulsante Crea profilo per terminare.Click the Create Profile button to finish.

Dopo aver creato un profilo di pubblicazione, la scheda Pubblica cambia.Once a publish profile is created, the Publish tab changes. Il nuovo profilo creato viene visualizzato in un elenco a discesa.The newly created profile appears in a drop-down list. Fare clic su Crea nuovo profilo per creare un altro nuovo profilo.Click Create new profile to create another new profile.

Scheda Pubblica della pagina di capacità dell'app che visualizza FolderProfile

La pubblicazione guidata supporta le seguenti destinazioni di pubblicazione:The Publish wizard supports the following publish targets:

  • Servizio app di AzureAzure App Service
  • Macchine virtuali di AzureAzure Virtual Machines
  • IIS, FTP e così via (per qualunque server Web)IIS, FTP, etc. (for any web server)
  • CartellaFolder
  • Importa profiloImport Profile

Per altre informazioni, vedere Quali sono le opzioni di pubblicazione più adatte?.For more information, see What publishing options are right for me.

Quando si crea un profilo di pubblicazione con Visual Studio, viene creato un file di MSBuild Properties/PublishProfiles/{NOME PROFILO}.pubxml.When creating a publish profile with Visual Studio, a Properties/PublishProfiles/{PROFILE NAME}.pubxml MSBuild file is created. Il file .pubxml è un file di MSBuild e contiene le impostazioni di configurazione della pubblicazione.The .pubxml file is a MSBuild file and contains publish configuration settings. Questo file può essere modificato per personalizzare il processo di compilazione e di pubblicazione.This file can be changed to customize the build and publish process. Questo file viene letto dal processo di pubblicazione.This file is read by the publishing process. <LastUsedBuildConfiguration> è speciale perché è una proprietà globale e non deve essere presente in alcun file importato nella compilazione.<LastUsedBuildConfiguration> is special because it's a global property and shouldn't be in any file that's imported in the build. Per altre informazioni, vedere MSBuild: how to set the configuration property (MSBuild: come impostare la proprietà di configurazione).See MSBuild: how to set the configuration property for more information.

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 in ASP.NET Core, vedere Ospitare e distribuire.For an overview of how to publish a web app on ASP.NET Core, see Host and deploy. Le attività e le destinazioni di MSBuild necessarie per pubblicare un'app ASP.NET Core sono open source in https://github.com/aspnet/websdk.The MSBuild tasks and targets necessary to publish an ASP.NET Core app are open-source at https://github.com/aspnet/websdk.

dotnet publish può usare profili di pubblicazione di tipo cartella, MSDeploy e Kudu:dotnet publish can use folder, MSDeploy, and Kudu publish profiles:

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

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

MSDeploy (attualmente funziona solo in Windows poiché MSDeploy non è multipiattaforma):MSDeploy (currently this only works in Windows since MSDeploy isn't cross-platform):

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

Pacchetto MSDeploy (attualmente funziona solo in Windows poiché MSDeploy non è multipiattaforma):MSDeploy package (currently this only works in Windows since MSDeploy isn't cross-platform):

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

Negli esempi precedenti non passare deployonbuild a dotnet publish.In the preceding samples, don't pass deployonbuild to dotnet publish.

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

dotnet publish supporta le API Kudu per la pubblicazione in Azure da qualsiasi piattaforma.dotnet publish supports 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.

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

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

Eseguire il comando seguente per comprimere il contenuto per la pubblicazione e pubblicarlo in Azure tramite le API Kudu:Run the following command to zip up the publish contents and publish it to Azure using the Kudu APIs:

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

Quando si usa un profilo di pubblicazione, impostare le proprietà di MSBuild seguenti:Set the following MSBuild properties when using a publish profile:

  • DeployOnBuild=true
  • PublishProfile={PUBLISH PROFILE}

Durante la pubblicazione con un profilo denominato FolderProfile, è possibile eseguire uno dei comandi riportati di seguito:When publishing with a profile named FolderProfile, either of the commands below can be executed:

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

Richiamando dotnet build, viene chiamato msbuild per eseguire il processo di compilazione e di pubblicazione.When invoking dotnet build, it calls msbuild to run the build and publish process. Quando si passa un profilo di cartella, è equivalente chiamare dotnet build o msbuild.Calling either dotnet build or msbuild is 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. MSDeploy è attualmente limitato ai computer Windows per la pubblicazione.MSDeploy is currently limited to Windows machines for publishing. Chiamando dotnet build in un profilo diverso dalla cartella viene richiamato MSBuild e MSBuild usa MSDeploy sui profili diversi dalle cartelle.Calling dotnet build on a non-folder profile invokes MSBuild, and MSBuild uses MSDeploy on non-folder profiles. Chiamando dotnet build in un profilo diverso dalla cartella viene richiamato MSBuild (mediante MSDeploy) e si ha come risultato un errore (anche nell'esecuzione su una piattaforma Windows).Calling dotnet build on a non-folder profile invokes MSBuild (using MSDeploy) and results in a failure (even when running on a Windows platform). Per la pubblicazione con un profilo diverso dalla 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>

Tenere presente che <LastUsedBuildConfiguration> è impostato su Release.Note <LastUsedBuildConfiguration> is set to Release. Nella pubblicazione da Visual Studio, il valore della proprietà di configurazione <LastUsedBuildConfiguration> viene impostato usando il valore, quando viene avviato il processo di pubblicazione.When publishing from Visual Studio, the <LastUsedBuildConfiguration> configuration property value is set using the value when the publish process is started. La proprietà di configurazione <LastUsedBuildConfiguration> è speciale e non deve essere sottoposta a override in un file di MSBuild importato.The <LastUsedBuildConfiguration> configuration property is special and shouldn't be overridden in an imported MSBuild file. È possibile eseguire l'override di questa proprietà dalla riga di comando.This property can be overridden from the command line.

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

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 Recupera 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 al prompt dei comandi di Windows:A publish profile can also be used with the .NET Core CLI dotnet msbuild command from a Windows command prompt:

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

Nota

Il comando dotnet msbuild è multipiattaforma e consente di compilare app ASP.NET Core in macOS e Linux.The dotnet msbuild command is available cross-platform 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 un altro endpoint MSDeploy.However, MSBuild on macOS and Linux isn't capable of deploying an app to Azure or other MSDeploy endpoint. MSDeploy è disponibile solo in Windows.MSDeploy is only available on Windows.

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 le app Web di ASP.NET Core, vengono inclusi gli artefatti di compilazione e il contenuto della cartella wwwroot.When publishing ASP.NET Core web apps, the build artifacts and contents of the wwwroot folder are included. msbuild supporta i criteri GLOB.msbuild supports globbing patterns. Ad esempio, l'elemento <Content> seguente esclude tutti i file di testo (.txt) dalla cartella wwwroot/content e da tutte le relative sottocartelle.For example, the following <Content> element excludes all text (.txt) files from the wwwroot/content folder and all 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 il seguente output:Using command-line deployment with the preceding <Content> element yields the following output:

MSDeployPublish:
  Starting Web deployment task from source: manifest(C:\Webs\Web1\obj\Release\netcoreapp1.1\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

Il markup seguente include una cartella images all'esterno della directory di progetto nella cartella wwwroot/images del sito di pubblicazione:The following markup includes an images folder outside the project directory to the wwwroot/images folder of the publish site:

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

Il markup può essere aggiunto al file .csproj o al profilo di pubblicazione.The markup 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.

Il markup evidenziato seguente illustra come:The following highlighted markup shows how to:

  • Copiare un file dall'esterno del progetto nella cartella wwwroot.Copy a file from outside the project into the wwwroot folder.
  • Escludere la cartella wwwroot\Content.Exclude the wwwroot\Content folder.
  • Escludere Views\Home\About2.cshtml.Exclude Views\Home\About2.cshtml.
<?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 />
    <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>

Per altri campioni di distribuzione vedere WebSDK Readme.See the WebSDK Readme for more deployment samples.

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