Perfis de publicação do Visual Studio para a implantação do aplicativo ASP.NET CoreVisual Studio publish profiles for ASP.NET Core app deployment

Por Sayed Hashimi de Ibrahim e Rick AndersonBy Sayed Ibrahim Hashimi and Rick Anderson

Este documento se concentra no uso do Visual Studio 2019 ou posterior para criar e usar perfis de publicação.This document focuses on using Visual Studio 2019 or later to create and use publish profiles. Os perfis de publicação criados com o Visual Studio podem ser usados com o MSBuild e o Visual Studio.The publish profiles created with Visual Studio can be used with MSBuild and Visual Studio. Para obter instruções sobre a publicação no Azure, confira Publicar um aplicativo ASP.NET Core no Azure com o Visual Studio.For instructions on publishing to Azure, see Publicar um aplicativo ASP.NET Core no Azure com o Visual Studio.

O comando dotnet new mvc produz um arquivo de projeto contendo o seguinte nível de raiz <Projeto> elemento: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>

O atributo Sdk do elemento <Project> anterior importa as propriedades e os destinos do MSBuild de $(MSBuildSDKsPath)\Microsoft.NET.Sdk.Web\Sdk\Sdk.props e $(MSBuildSDKsPath)\Microsoft.NET.Sdk.Web\Sdk\Sdk.targets, respectivamente.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. O local padrão para $(MSBuildSDKsPath) (com o Visual Studio 2019 Enterprise) é a pasta %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 (SDK da Web) depende de outros SDKs, incluindo Microsoft.NET.Sdk (SDK do .NET Core) e Microsoft.NET.Sdk.Razor (SDK do Razor).Microsoft.NET.Sdk.Web (Web SDK) depends on other SDKs, including Microsoft.NET.Sdk (.NET Core SDK) and Microsoft.NET.Sdk.Razor (Razor SDK). As propriedades e os destinos do MSBuild associados a cada SDK dependente são importados.The MSBuild properties and targets associated with each dependent SDK are imported. Os destinos de publicação importam o conjunto apropriado de destinos com base no método de publicação usado.Publish targets import the appropriate set of targets based on the publish method used.

Quando o MSBuild ou o Visual Studio carrega um projeto, as seguintes ações de nível alto ocorrem:When MSBuild or Visual Studio loads a project, the following high-level actions occur:

  • Compilar projetoBuild project
  • Computar arquivos a publicarCompute files to publish
  • Publicar arquivos para o destinoPublish files to destination

Itens de projeto de computaçãoCompute project items

Quando o projeto é carregado, os itens de projeto do MSBuild (arquivos) são computados.When the project is loaded, the MSBuild project items (files) are computed. O tipo de item determina como o arquivo é processado.The item type determines how the file is processed. Por padrão, os arquivos .cs são incluídos na lista de itens Compile.By default, .cs files are included in the Compile item list. Os arquivos na lista de itens Compile são compilados.Files in the Compile item list are compiled.

A lista de itens Content contém arquivos que são publicados juntamente com as saídas de build.The Content item list contains files that are published in addition to the build outputs. Por padrão, os arquivos que correspondem aos padrões wwwroot\**, **\*.config e **\*.json são incluídos na lista de itens Content.By default, files matching the patterns wwwroot\**, **\*.config, and **\*.json are included in the Content item list. Por exemplo, o padrão de recurso de curinga wwwroot\** corresponde a todos os arquivos na pasta wwwroot e suas subpastas.For example, the wwwroot\** globbing pattern matches all files in the wwwroot folder and its subfolders.

O SDK da Web importa o SDK do Razor.The Web SDK imports the Razor SDK. Como resultado, os arquivos que correspondem aos padrões **\*.cshtml e **\*.razor também são incluídos na lista de itens Content.As a result, files matching the patterns **\*.cshtml and **\*.razor are also included in the Content item list.

O SDK da Web importa o SDK do Razor.The Web SDK imports the Razor SDK. Como resultado, os arquivos que correspondem ao padrão **\*.cshtml também são incluídos na lista de itens Content.As a result, files matching the **\*.cshtml pattern are also included in the Content item list.

Para adicionar explicitamente um arquivo à lista de publicação, adicione o arquivo diretamente no arquivo .csproj, conforme mostrado na seção Incluir Arquivos.To explicitly add a file to the publish list, add the file directly in the .csproj file as shown in the Include Files section.

Ao selecionar o botão Publicar no Visual Studio ou ao publicar da linha de comando:When selecting the Publish button in Visual Studio or when publishing from the command line:

  • Os itens/propriedades são calculados (os arquivos necessários para compilar).The properties/items are computed (the files that are needed to build).
  • Somente Visual Studio: os pacotes do NuGet são restaurados.Visual Studio only: NuGet packages are restored. (A restauração precisa ser explícita pelo usuário na CLI.)(Restore needs to be explicit by the user on the CLI.)
  • O projeto é compilado.The project builds.
  • Os itens de publicação são computados (os arquivos necessários para a publicação).The publish items are computed (the files that are needed to publish).
  • O projeto é publicado (os arquivos computados são copiados para o destino de publicação).The project is published (the computed files are copied to the publish destination).

Quando um projeto do ASP.NET Core faz referência a Microsoft.NET.Sdk.Web no arquivo de projeto, um arquivo app_offline.htm é colocado na raiz do diretório do aplicativo Web.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 o arquivo estiver presente, o módulo do ASP.NET Core apenas desligará o aplicativo e servirá o arquivo app_offline.htm durante a implantação.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. Para obter mais informações, consulte Referência de configuração do módulo do ASP.NET Core.For more information, see the ASP.NET Core Module configuration reference.

Publicação de linha de comando básicaBasic command-line publishing

A publicação de linha de comando funciona em todas as plataformas compatíveis com o .NET Core e não requer o Visual Studio.Command-line publishing works on all .NET Core-supported platforms and doesn't require Visual Studio. Nos exemplos a seguir, o comando dotnet publish da CLI do .NET Core é executado no diretório do projeto (que contém o arquivo .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 a pasta do projeto não for o diretório de trabalho atual, passe explicitamente no caminho do arquivo de projeto.If the project folder isn't the current working directory, explicitly pass in the project file path. Por exemplo:For example:

dotnet publish C:\Webs\Web1

Execute os comandos a seguir para criar e publicar um aplicativo Web:Run the following commands to create and publish a web app:

dotnet new mvc
dotnet publish

O comando dotnet publish produz uma variação da saída a seguir: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\

O formato da pasta de publicação padrão é bin\Debug\{MONIKER DA ESTRUTURA DE DESTINO}\publish\ .The default publish folder format is bin\Debug\{TARGET FRAMEWORK MONIKER}\publish\. Por exemplo, bin\Debug\netcoreapp2.2\publish\ .For example, bin\Debug\netcoreapp2.2\publish\.

O comando a seguir especifica um build de Release e o diretório de publicação:The following command specifies a Release build and the publishing directory:

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

O comando dotnet publish chama MSBuild, que invoca o destino Publish.The dotnet publish command calls MSBuild, which invokes the Publish target. Quaisquer parâmetros passados para dotnet publish são passados para o MSBuild.Any parameters passed to dotnet publish are passed to MSBuild. Os parâmetros -c e -o mapeiam as propriedades Configuration e OutputPath do MSBuild, respectivamente.The -c and -o parameters map to MSBuild's Configuration and OutputPath properties, respectively.

Propriedades do MSBuild podem ser passadas usando qualquer um dos seguintes formatos:MSBuild properties can be passed using either of the following formats:

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

Por exemplo, o comando a seguir publica um build de Release para um compartilhamento de rede.For example, the following command publishes a Release build to a network share. O compartilhamento de rede é especificado com barras "/" ( //r8/ ) e funciona em todas as plataformas com suporte do .NET Core.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

Confirme que o aplicativo publicado para implantação não está em execução.Confirm that the published app for deployment isn't running. Os arquivos da pasta publish são bloqueados quando o aplicativo está em execução.Files in the publish folder are locked when the app is running. A implantação não pode ocorrer porque arquivos bloqueados não podem ser copiados.Deployment can't occur because locked files can't be copied.

Perfis de publicaçãoPublish profiles

Esta seção usa o Visual Studio 2019 ou posterior para criar um perfil de publicação.This section uses Visual Studio 2019 or later to create a publishing profile. Uma vez criado, é possível publicar do Visual Studio ou da linha de comando.Once the profile is created, publishing from Visual Studio or the command line is available. Perfis de publicação podem simplificar o processo de publicação e podem existir em qualquer número.Publish profiles can simplify the publishing process, and any number of profiles can exist.

Crie um perfil de publicação no Visual Studio escolhendo um dos seguintes caminhos:Create a publish profile in Visual Studio by choosing one of the following paths:

  • Clique com o botão direito do mouse no projeto no Gerenciador de soluções e selecione publicar.Right-click the project in Solution Explorer and select Publish.
  • Selecione Publicar {NOME DO PROJETO} no menu Build.Select Publish {PROJECT NAME} from the Build menu.

A guia Publicar da página de capacidades do aplicativo é exibida.The Publish tab of the app capabilities page is displayed. Se o projeto não tiver um perfil de publicação, a página Escolher um destino de publicação é exibida.If the project lacks a publish profile, the Pick a publish target page is displayed. Você deverá selecionar um dos seguintes destinos de publicação:You're asked to select one of the following publish targets:

  • Serviço de Aplicativo do AzureAzure App Service
  • Serviço de Aplicativo do Azure no LinuxAzure App Service on Linux
  • Máquinas Virtuais do AzureAzure Virtual Machines
  • PastaFolder
  • Implantação da Web, IIS, FTP (para qualquer servidor web)IIS, FTP, Web Deploy (for any web server)
  • Importar PerfilImport Profile

Para determinar o destino de publicação mais apropriado, confira Quais opções de publicação são adequadas para mim.To determine the most appropriate publish target, see What publishing options are right for me.

Quando o destino de publicação Pasta é selecionado, especifique um caminho de pasta para armazenar os ativos publicados.When the Folder publish target is selected, specify a folder path to store the published assets. O caminho de pasta padrão é bin\{CONFIGURAÇÃO DO PROJETO}\{MONIKER DA ESTRUTURA DE DESTINO}\publish\ .The default folder path is bin\{PROJECT CONFIGURATION}\{TARGET FRAMEWORK MONIKER}\publish\. Por exemplo, bin\Release\netcoreapp2.2\publish\ .For example, bin\Release\netcoreapp2.2\publish\. Selecione o botão Criar Perfil para concluir.Select the Create Profile button to finish.

Depois de um perfil de publicação ser criado, o conteúdo da guia Publicar é alterado.Once a publish profile is created, the Publish tab's content changes. O perfil recém-criado é exibido em uma lista suspensa.The newly created profile appears in a drop-down list. Abaixo da lista suspensa, selecione Criar novo perfil para criar outro novo perfil.Below the drop-down list, select Create new profile to create another new profile.

A ferramenta de publicação do Visual Studio cria um arquivo MSBuild Properties/PublishProfiles/{NOME DO PERFIL}.pubxml que descreve o perfil de publicação.Visual Studio's publish tool produces a Properties/PublishProfiles/{PROFILE NAME}.pubxml MSBuild file describing the publish profile. O arquivo .pubxml:The .pubxml file:

  • Contém as definições de configuração de publicação e é consumido pelo processo de publicação.Contains publish configuration settings and is consumed by the publishing process.
  • Pode ser modificado para personalizar o processo de compilação e publicação.Can be modified to customize the build and publish process.

Ao publicar em um destino do Azure, o arquivo .pubxml contém o identificador de assinatura do Azure.When publishing to an Azure target, the .pubxml file contains your Azure subscription identifier. Com esse tipo de destino, não é recomendável adicionar esse arquivo ao controle do código-fonte.With that target type, adding this file to source control is discouraged. Ao publicar em um destino não Azure, é seguro fazer check-in do arquivo .pubxml.When publishing to a non-Azure target, it's safe to check in the .pubxml file.

Informações confidenciais (como a senha de publicação) são criptografadas em um nível por usuário/computador.Sensitive information (like the publish password) is encrypted on a per user/machine level. Elas são armazenadas no arquivo Properties/PublishProfiles/{NOME DO PERFIL}.pubxml.user.It's stored in the Properties/PublishProfiles/{PROFILE NAME}.pubxml.user file. Já que esse arquivo pode armazenar informações confidenciais, o check-in dele não deve ser realizado no controle do código-fonte.Because this file can store sensitive information, it shouldn't be checked into source control.

Para obter uma visão geral de como publicar um aplicativo web ASP.NET Core, confira Hospedar e implantar o ASP.NET Core.For an overview of how to publish an ASP.NET Core web app, see Hospedar e implantar o ASP.NET Core. As tarefas e os destinos de MSBuild necessários para publicar um aplicativo Web ASP.NET Core são open-source no repositório aspnet/websdk.The MSBuild tasks and targets necessary to publish an ASP.NET Core web app are open-source at the aspnet/websdk repository.

O comando dotnet publish pode usar os perfis de publicação de pasta, MSDeploy e Kudu.The dotnet publish command can use folder, MSDeploy, and Kudu publish profiles. Porque o MSDeploy não oferece suporte em plataforma cruzada, as seguintes opções de MSDeploy têm suporte apenas no Windows.Because MSDeploy lacks cross-platform support, the following MSDeploy options are supported only on Windows.

Pasta (funciona em plataforma cruzada):Folder (works cross-platform):

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

MSDeploy:MSDeploy:

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

Pacote do MSDeploy:MSDeploy package:

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

Nos exemplos anteriores, não passe deployonbuild para dotnet publish.In the preceding examples, don't pass deployonbuild to dotnet publish.

Para obter mais informações, confira Microsoft.NET.Sdk.Publish.For more information, see Microsoft.NET.Sdk.Publish.

O dotnet publish dá suporte às APIs do Kudu, para publicar no Azure de qualquer plataforma.dotnet publish supports Kudu APIs to publish to Azure from any platform. A publicação do Visual Studio dá suporte às APIs do Kudu, mas ela é compatível com o WebSDK para publicação multiplataforma para o Azure.Visual Studio publish supports the Kudu APIs, but it's supported by WebSDK for cross-platform publish to Azure.

Adicione um perfil de publicação à pasta Properties/PublishProfiles do projeto com o seguinte conteúdo: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>

Execute o seguinte comando para compactar os conteúdos de publicação e publicá-los no Azure usando as APIs do 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

Defina as seguintes propriedades de MSBuild ao usar um perfil de publicação:Set the following MSBuild properties when using a publish profile:

  • DeployOnBuild=true
  • PublishProfile={PUBLISH PROFILE}

Ao publicar com um perfil chamado FolderProfile, é possível executar qualquer um dos comandos abaixo: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

O comando dotnet build da CLI do .NET Core chama msbuild para executar a compilação e o processo de publicação.The .NET Core CLI's dotnet build command calls msbuild to run the build and publish process. Os comandos dotnet build e msbuild são equivalentes ao passar em um perfil de pasta.The dotnet build and msbuild commands are equivalent when passing in a folder profile. Ao chamar o msbuild diretamente no Windows, a versão do .NET Framework do MSBuild é usada.When calling msbuild directly on Windows, the .NET Framework version of MSBuild is used. Chamar dotnet build em um perfil não de pasta:Calling dotnet build on a non-folder profile:

  • Invoca msbuild, que usa MSDeploy.Invokes msbuild, which uses MSDeploy.
  • Resulta em uma falha (mesmo quando em execução no Windows).Results in a failure (even when running on Windows). Para publicar com um perfil não de pasta, chame o msbuild diretamente.To publish with a non-folder profile, call msbuild directly.

A pasta de perfil de publicação a seguir foi criada com o Visual Studio e publica em um compartilhamento de rede: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>

No exemplo anterior:In the preceding example:

  • A propriedade <ExcludeApp_Data> está presente, simplesmente para satisfazer um requisito de esquema XML.The <ExcludeApp_Data> property is present merely to satisfy an XML schema requirement. A propriedade <ExcludeApp_Data> não tem efeito sobre o processo de publicação, mesmo se houver uma pasta App_Data na raiz do projeto.The <ExcludeApp_Data> property has no effect on the publish process, even if there's an App_Data folder in the project root. A pasta App_Data não recebe tratamento especial, como faz em projetos do ASP.NET 4.x.The App_Data folder doesn't receive special treatment as it does in ASP.NET 4.x projects.

  • A propriedade <LastUsedBuildConfiguration> é definida como Release.The <LastUsedBuildConfiguration> property is set to Release. Ao publicar no Visual Studio, o valor de <LastUsedBuildConfiguration> é definido usando o valor quando o processo de publicação é iniciado.When publishing from Visual Studio, the value of <LastUsedBuildConfiguration> is set using the value when the publish process is started. <LastUsedBuildConfiguration> é especial e não deve ser substituída em um arquivo do MSBuild importado.<LastUsedBuildConfiguration> is special and shouldn't be overridden in an imported MSBuild file. Essa propriedade pode, no entanto, ser substituída na linha de comando usando uma das abordagens a seguir.This property can, however, be overridden from the command line using one of the following approaches.

    • Usando a CLI do .NET Core:Using the .NET Core CLI:

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

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

    Para saber mais, confira MSBuild: como definir a propriedade de configuração.For more information, see MSBuild: how to set the configuration property.

Publicar em um ponto de extremidade do MSDeploy da linha de comandoPublish to an MSDeploy endpoint from the command line

O exemplo a seguir usa um aplicativo Web do ASP.NET Core, criado pelo Visual Studio, denominada AzureWebApp.The following example uses an ASP.NET Core web app created by Visual Studio named AzureWebApp. Um perfil de publicação dos aplicativos do Azure é adicionado ao Visual Studio.An Azure Apps publish profile is added with Visual Studio. Para obter mais informações sobre como criar um perfil, consulte a seção Perfis de publicação.For more information on how to create a profile, see the Publish profiles section.

Para implantar o aplicativo usando um perfil de publicação, execute o comando msbuild de um Prompt de Comando do Desenvolvedor do Visual Studio.To deploy the app using a publish profile, execute the msbuild command from a Visual Studio Developer Command Prompt. O prompt de comando está disponível na pasta do Visual Studio do menu Página Inicial na barra de tarefas do Windows.The command prompt is available in the Visual Studio folder of the Start menu on the Windows taskbar. Para facilitar o acesso, você pode adicionar o prompt de comando ao menu Ferramentas no Visual Studio.For easier access, you can add the command prompt to the Tools menu in Visual Studio. Para saber mais, confira Prompt de comando do desenvolvedor para Visual Studio.For more information, see Developer Command Prompt for Visual Studio.

O MSBuild usa a sintaxe de comando a seguir:MSBuild uses the following command syntax:

msbuild {PATH} 
    /p:DeployOnBuild=true 
    /p:PublishProfile={PROFILE} 
    /p:Username={USERNAME} 
    /p:Password={PASSWORD}
  • {CAMINHO} – Caminho para o arquivo de projeto do aplicativo.{PATH} – Path to the app's project file.
  • {PERFIL} – Nome do perfil de publicação.{PROFILE} – Name of the publish profile.
  • {NOME DE USUÁRIO} – Nome de usuário do MSDeploy.{USERNAME} – MSDeploy username. O {NOME DE USUÁRIO} pode ser encontrado no perfil de publicação.The {USERNAME} can be found in the publish profile.
  • {SENHA} – Senha do MSDeploy.{PASSWORD} – MSDeploy password. Obtenha a {SENHA} do arquivo {PERFIL}.PublishSettings.Obtain the {PASSWORD} from the {PROFILE}.PublishSettings file. Baixe o arquivo .PublishSettings de uma das seguintes opções:Download the .PublishSettings file from either:
    • Gerenciador de Soluções: Selecione Exibição ****Cloud Explorer**.Solution Explorer: Select View > Cloud Explorer. Conecte-se à sua assinatura do Azure.Connect with your Azure subscription. Abra Serviços de Aplicativos.Open App Services. Clique com o botão direito do mouse no aplicativo.Right-click the app. Selecione Baixar Perfil de Publicação.Select Download Publish Profile.
    • Portal do Azure: selecione Obter perfil de publicação no painel Visão geral de seu aplicativo Web.Azure portal: Select Get publish profile in the web app's Overview panel.

O exemplo a seguir usa um perfil de publicação denominado AzureWebApp – Implantação da Web: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=".........."

Um perfil de publicação também pode ser usado com o comando dotnet msbuild da CLI do .NET Core em um shell de comando do 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

O comando dotnet msbuild é um comando de plataforma cruzada e pode compilar os aplicativos ASP.NET Core no macOS e Linux.The dotnet msbuild command is a cross-platform command and can compile ASP.NET Core apps on macOS and Linux. No entanto, o MSBuild no macOS e Linux não é capaz de implantar um aplicativo no Azure ou em outros pontos de extremidade do MSDeploy.However, MSBuild on macOS and Linux isn't capable of deploying an app to Azure or other MSDeploy endpoints.

Definir o ambienteSet the environment

Inclua a propriedade <EnvironmentName> no perfil de publicação ( .pubxml) ou no arquivo de projeto para definir o ambiente do aplicativo:Include the <EnvironmentName> property in the publish profile (.pubxml) or project file to set the app's environment:

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

Se você precisar de transformações do web.config (por exemplo, definir variáveis ​​de ambiente com base na configuração, no perfil ou no ambiente), confira Transformação do web.config.If you require web.config transformations (for example, setting environment variables based on the configuration, profile, or environment), see Transformação do web.config.

Excluir arquivosExclude files

Ao publicar aplicativos Web ASP.NET Core, os seguintes ativos são incluídos:When publishing ASP.NET Core web apps, the following assets are included:

  • Artefatos de compilaçãoBuild artifacts
  • As pastas e os arquivos que correspondem aos seguintes padrões de recurso de curinga:Folders and files matching the following globbing patterns:
    • **\*.config (por exemplo, web.config)**\*.config (for example, web.config)
    • **\*.json (por exemplo, appsettings.json)**\*.json (for example, appsettings.json)
    • wwwroot\**

O MSBuild dá suporte aos padrões de recurso de curinga.MSBuild supports globbing patterns. Por exemplo, o elemento <Content> a seguir suprime a cópia dos arquivos de texto ( .txt) na pasta wwwroot\content e suas subpastas: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>

A marcação anterior pode ser adicionada a um perfil de publicação ou ao arquivo .csproj.The preceding markup can be added to a publish profile or the .csproj file. Quando adicionada ao arquivo .csproj, a regra será adicionada a todos os perfis de publicação no projeto.When added to the .csproj file, the rule is added to all publish profiles in the project.

O elemento <MsDeploySkipRules> a seguir exclui todos os arquivos da pasta 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> não exclui os destinos de ignorados do site de implantação.<MsDeploySkipRules> won't delete the skip targets from the deployment site. Pastas e arquivos de destino de <Content> são excluídos do site de implantação.<Content> targeted files and folders are deleted from the deployment site. Por exemplo, suponha que um aplicativo Web implantado tinha os seguintes arquivos: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

Nos elementos <MsDeploySkipRules> a seguir, esses arquivos não seriam excluídos no site de implantação.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>

Os elementos <MsDeploySkipRules> anteriores impedem que os arquivos ignorados sejam implantados.The preceding <MsDeploySkipRules> elements prevent the skipped files from being deployed. Ele não excluirá esses arquivos depois que eles forem implantados.It won't delete those files once they're deployed.

O elemento <Content> a seguir exclui os arquivos de destino no site de implantação:The following <Content> element deletes the targeted files at the deployment site:

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

O uso da implantação de linha de comando com o elemento <Content> anterior produz uma variação da seguinte saída: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).

Incluir arquivosInclude files

As seções a seguir descrevem diferentes abordagens para inclusão de arquivos no momento da publicação.The following sections outline different approaches for file inclusion at publish time. A seção Inclusão de arquivos gerais usa o item DotNetPublishFiles, que é fornecido por um arquivo de destinos de publicação no SDK da Web.The General file inclusion section uses the DotNetPublishFiles item, which is provided by a publish targets file in the Web SDK. A seção Inclusão de arquivos seletivos usa o item ResolvedFileToPublish, que é fornecido por um arquivo de destinos de publicação no SDK do .NET Core.The Selective file inclusion section uses the ResolvedFileToPublish item, which is provided by a publish targets file in the .NET Core SDK. Como o SDK para Web depende do SDK do .NET Core, qualquer item pode ser usado em um projeto do ASP.NET Core.Because the Web SDK depends on the .NET Core SDK, either item can be used in an ASP.NET Core project.

Inclusão de arquivos geraisGeneral file inclusion

O elemento <ItemGroup> do exemplo a seguir demonstra como copiar uma pasta localizada fora do diretório do projeto para uma pasta do site publicado.The following example's <ItemGroup> element demonstrates copying a folder located outside of the project directory to a folder of the published site. Qualquer arquivo adicionado ao <ItemGroup> da marcação a seguir são incluídos por padrão.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>

A marcação anterior:The preceding markup:

  • Pode ser adicionada ao arquivo .csproj ou ao perfil de publicação.Can be added to the .csproj file or the publish profile. Se ela for adicionada ao arquivo .csproj, ela será incluída em cada perfil de publicação no projeto.If it's added to the .csproj file, it's included in each publish profile in the project.
  • Declara um item _CustomFiles para armazenar os arquivos correspondendo ao padrão de recurso de curinga do atributo Include.Declares a _CustomFiles item to store files matching the Include attribute's globbing pattern. A pasta imagens referenciada no padrão está localizada fora do diretório do projeto.The images folder referenced in the pattern is located outside of the project directory. Uma propriedade reservada, denominada $(MSBuildProjectDirectory), resolve o caminho absoluto do arquivo de projeto.A reserved property, named $(MSBuildProjectDirectory), resolves to the project file's absolute path.
  • Fornece uma lista de arquivos para o item DotNetPublishFiles.Provides a list of files to the DotNetPublishFiles item. Por padrão, o elemento <DestinationRelativePath> do item está vazio.By default, the item's <DestinationRelativePath> element is empty. O valor padrão é substituído na marcação e usa metadados de item bem conhecidos, como %(RecursiveDir).The default value is overridden in the markup and uses well-known item metadata such as %(RecursiveDir). O texto interno representa a pasta wwwroot/images do site publicado.The inner text represents the wwwroot/images folder of the published site.

Inclusão de arquivo seletivoSelective file inclusion

A marcação realçada no exemplo a seguir demonstra:The highlighted markup in the following example demonstrates:

  • Copiar um arquivo localizado fora do projeto para a pasta wwwroot do site publicado.Copying a file located outside of the project into the published site's wwwroot folder. O nome de arquivo ReadMe2.md é mantido.The file name of ReadMe2.md is maintained.
  • Excluir a pasta wwwroot\Content.Excluding the wwwroot\Content folder.
  • Excluir 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>

O exemplo anterior usa o item ResolvedFileToPublish, cujo comportamento padrão é sempre copiar os arquivos fornecidos no atributo Include para o site publicado.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. Substituir o comportamento padrão, incluindo um elemento filho <CopyToPublishDirectory> com o texto interno de um Never ou PreserveNewest.Override the default behavior by including a <CopyToPublishDirectory> child element with inner text of either Never or PreserveNewest. Por exemplo:For example:

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

Para obter mais amostras de implantação, confira o Leiame do repositório do SDK da Web.For more deployment samples, see the Web SDK repository Readme.

Executar um destino antes ou depois da publicaçãoRun a target before or after publishing

Os destinos BeforePublish e AfterPublish internos executam um destino antes ou após o destino de publicação.The built-in BeforePublish and AfterPublish targets execute a target before or after the publish target. Adicione os elementos a seguir ao perfil de publicação para registrar em log as mensagens de console antes e após a publicação: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>

Publicar em um servidor usando um certificado não confiávelPublish to a server using an untrusted certificate

Adicione a propriedade <AllowUntrustedCertificate> com um valor True ao perfil de publicação:Add the <AllowUntrustedCertificate> property with a value of True to the publish profile:

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

O serviço KuduThe Kudu service

Para exibir os arquivos em uma implantação de aplicativo Web do Serviço de Aplicativo do Azure, use o serviço Kudu.To view the files in an Azure App Service web app deployment, use the Kudu service. Acrescente o token scm ao nome do aplicativo Web.Append the scm token to the web app name. Por exemplo:For example:

URLURL ResultadoResult
http://mysite.azurewebsites.net/ Aplicativo WebWeb App
http://mysite.scm.azurewebsites.net/ Serviço KuduKudu service

Selecione o item de menu Console de Depuração para exibir, editar, excluir ou adicionar arquivos.Select the Debug Console menu item to view, edit, delete, or add files.

Recursos adicionaisAdditional resources