Perfiles de publicación (.pubxml) de Visual Studio para la implementación de aplicaciones ASP.NET Core

  • Artículo

Por Sayed Ibrahim Hashimi y Rick Anderson

Este documento se centra en el uso de Visual Studio 2019 o versiones posteriores para crear y usar perfiles de publicación. Los perfiles de publicación creados con Visual Studio se pueden usar con MSBuild y Visual Studio. Para obtener instrucciones sobre cómo publicar en Azure, vea Publicar una aplicación de ASP.NET Core en Azure con Visual Studio.

Con el comando dotnet new mvc se produce un archivo de proyecto que contiene el siguiente elemento <Project> de nivel de raíz:

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

El atributo Sdk del elemento anterior <Project> importa las propiedades y objetivos de $(MSBuildSDKsPath)\Microsoft.NET.Sdk.Web\Sdk\Sdk.props y $(MSBuildSDKsPath)\Microsoft.NET.Sdk.Web\Sdk\Sdk.targets, respectivamente. La ubicación predeterminada de $(MSBuildSDKsPath) (con Visual Studio 2019 Enterprise) es la carpeta %programfiles(x86)%\Microsoft Visual Studio\2019\Enterprise\MSBuild\Sdks.

Microsoft.NET.Sdk.Web (SDK web) depende de otros SDK, como Microsoft.NET.Sdk (SDK de .NET Core) y Microsoft.NET.Sdk.Razor (SDK de Razor). Se importan las propiedades y objetivos de MSBuild asociados con cada SDK dependiente. Los destinos de publicación importan el conjunto adecuado de destinos en función del método de publicación usado.

Cuando se carga un proyecto en Visual Studio o MSBuild, se llevan a cabo las siguientes acciones generales:

  • Compilación del proyecto
  • Cálculo de los archivos para la publicación
  • Publicación de los archivos en el destino

Cálculo de los elementos del proyecto

Cuando se carga el proyecto, se procesan los elementos del proyecto de MSBuild (archivos). El tipo de elemento determina cómo se procesa el archivo. De forma predeterminada, los archivos .cs se incluyen en la lista de elementos Compile. Después se compilan los archivos de la lista de elementos Compile.

La lista de elementos Content contiene archivos que se van a publicar, además de los resultados de compilación. De forma predeterminada, los archivos que coinciden con los patrones wwwroot\**, **\*.config y **\*.json se incluyen en la lista de elementos Content. Por ejemplo, el patrón globalwwwroot\** coincide con los archivos de la carpeta wwwroot y de sus subcarpetas.

El SDK web importa el SDK de Razor. Como resultado, los archivos que coinciden con los patrones **\*.cshtml y **\*.razor se incluyen también en la lista de elementos Content.

El SDK web importa el SDK de Razor. Como resultado, los archivos que coinciden con el patrón **\*.cshtml y se incluye también en la lista de elementos Content.

Para agregar explícitamente un archivo a la lista de publicación, agregue el archivo directamente en el archivo .csproj, como se muestra en la sección Archivos de inclusión.

Al seleccionar el botón Publicar en Visual Studio o al publicar desde la línea de comandos:

  • Se calculan los elementos/propiedades (los archivos que se deben compilar).
  • Solo Visual Studio: Se han restaurado los paquetes NuGet. (la restauración debe ser explícita por parte del usuario en la CLI).
  • Se compila el proyecto.
  • Se calculan los elementos de publicación (los archivos que se deben publicar).
  • Se publica el proyecto (los archivos calculados se copian en el destino de publicación).

Cuando un proyecto de ASP.NET Core hace referencia a Microsoft.NET.Sdk.Web en el archivo de proyecto, se coloca un archivo app_offline.htm en la raíz del directorio de la aplicación web. Cuando el archivo está presente, el módulo de ASP.NET Core cierra correctamente la aplicación y proporciona el archivo app_offline.htm durante la implementación. Para más información, vea ASP.NET Core Module configuration reference (Referencia de configuración del módulo de ASP.NET Core).

Publicación básica de línea de comandos

La publicación de línea de comandos funciona en todas las plataformas admitidas de .NET Core y no se requiere Visual Studio. En los ejemplos siguientes, se ejecuta el comando dotnet publish de la CLI de .NET Core desde el directorio del proyecto (que contiene el archivo .csproj). Si la carpeta del proyecto no es el directorio de trabajo actual, pase de forma explícita la ruta de acceso del archivo del proyecto. Por ejemplo:

dotnet publish C:\Webs\Web1

Ejecute los comandos siguientes para crear y publicar una aplicación web:

dotnet new mvc
dotnet publish

Con el comando dotnet publish se genera una variación de la salida siguiente:

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\

El formato de la carpeta de publicación predeterminado es bin\Debug\{TARGET FRAMEWORK MONIKER}\publish\. Por ejemplo, bin\Debug\netcoreapp2.2\publish\.

El siguiente comando especifica una compilación Release y el directorio de publicación:

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

Con el comando dotnet publish se llama a MSBuild, lo que invoca el destino Publish. Todos los parámetros pasados a dotnet publish se pasan a MSBuild. Los parámetros -c y -o se asignan respectivamente a las propiedades Configuration y OutputPath de MSBuild.

Se pueden pasar propiedades de MSBuild mediante cualquiera de los siguientes formatos:

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

Por ejemplo, el comando siguiente publica una compilación Release en un recurso compartido de red. El recurso compartido de red se especifica con barras diagonales ( //r8/ ) y funciona en todas las plataformas compatibles de .NET Core.

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

Confirme que la aplicación publicada para la implementación no se está ejecutando. Los archivos de la carpeta publish quedan bloqueados mientras se ejecuta la aplicación. No se puede llevar a cabo la implementación porque no se pueden copiar los archivos bloqueados.

Publicar los perfiles

En esta sección se usa Visual Studio 2019 o versiones posteriores para crear un perfil de publicación. Una vez creado el perfil, es posible realizar la publicación desde Visual Studio o la línea de comandos. Los perfiles de publicación pueden simplificar el proceso de publicación, y puede existir cualquier número de perfiles.

Cree un perfil de publicación en Visual Studio mediante la selección de una de las rutas de acceso siguientes:

  • Haga clic con el botón derecho en el proyecto, en el Explorador de soluciones, y seleccione Publicar.
  • Seleccione Publicar {NOMBRE DEL PROYECTO} en el menú Compilar.

Aparece la pestaña Publicar de la página de funcionalidades de la aplicación. Si el proyecto no contiene ningún perfil de publicación, se muestra la página Elegir un destino de publicación. Se le pide que seleccione uno de los siguientes destinos de publicación:

  • Azure App Service
  • Azure App Service en Linux
  • Azure Virtual Machines
  • Carpeta
  • IIS, FTP, Web Deploy (para cualquier servidor web)
  • Perfil de importación

Para determinar el destino de publicación más adecuado, consulte Qué opciones de publicación son las adecuadas para mí.

Cuando seleccione el destino de publicación Carpeta, especifique una ruta de acceso a la carpeta para almacenar los recursos publicados. La ruta de acceso de la carpeta predeterminada es bin\{PROJECT CONFIGURATION}\{TARGET FRAMEWORK MONIKER}\publish\. Por ejemplo, bin\Release\netcoreapp2.2\publish\. Seleccione el botón Crear perfil para terminar.

Una vez que se crea un perfil de publicación, cambia el contenido de la pestaña Publicar. El perfil recién creado aparece en una lista desplegable. Debajo de la lista desplegable, seleccione Crear nuevo perfil para crear otro perfil nuevo.

La herramienta de publicación de Visual Studio genera un archivo MSBuild denominado Properties/PublishProfiles/{NOMBRE DEL PERFIL}.pubxml en el que se describe el perfil de publicación. El archivo .pubxml:

  • Contiene los valores de la configuración de publicación y es utilizado por el proceso de publicación.
  • Se puede modificar para personalizar el proceso de compilación y publicación.

Al publicar en un destino de Azure, el archivo .pubxml contiene el identificador de suscripción de Azure. Con ese tipo de destino, no se recomienda agregar este archivo al control de código fuente. Al publicar en un destino que no sea Azure, es seguro insertar el archivo .pubxml en el repositorio.

La información confidencial (por ejemplo, la contraseña de publicación) se cifra en cada usuario y máquina. Este se almacena en el archivo Properties/PublishProfiles/{NOMBRE DEL PERFIL}.pubxml.user. Como este archivo puede contener información confidencial, no se debe insertar en el repositorio de control del código fuente.

Para información general sobre cómo publicar una aplicación web de ASP.NET Core, vea Hospedaje e implementación de ASP.NET Core. Las tareas y los destinos de MSBuild necesarios para publicar una aplicación web de ASP.NET Core son de código abierto en el repositorio dotnet/websdk.

Los siguientes comandos pueden usar perfiles de publicación de carpeta, MSDeploy y Kudu. Ya que MSDeploy no tiene compatibilidad multiplataforma, las siguientes opciones de MSDeploy solo se admiten en Windows.

Carpeta (funciona entre plataformas):

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

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

MSDeploy:

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

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

Paquete MSDeploy:

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

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

En los ejemplos anteriores:

  • dotnet publish y dotnet build admiten API de Kudu para publicar en Azure desde cualquier plataforma. La publicación de Visual Studio admite API de Kudu, pero es compatible con WebSDK para la publicación multiplataforma en Azure.
  • No pase DeployOnBuild al comando dotnet publish.

Para más información, consulte Microsoft.NET.Sdk.Publish.

Agregue un perfil de publicación a la carpeta del proyecto Properties/PublishProfiles con el contenido siguiente:

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

Ejemplo de publicación de carpetas

Al publicar con un perfil llamado FolderProfile , use cualquiera de los siguientes comandos:

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

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

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

Con el comando dotnet build de la CLI de .NET Core se llama a msbuild para ejecutar el proceso de compilación y publicación. Los comandos dotnet build y msbuild son equivalentes cuando se pasa un perfil de carpeta. Al llamar a msbuild directamente en Windows, se usa la versión de .NET Framework de MSBuild. Llamada a dotnet build en un perfil que no sea de carpeta:

  • Invoca msbuild, que usa MSDeploy.
  • Produce un error (incluso cuando se ejecuta en Windows). Para publicar con un perfil que no es de carpeta, llame directamente a msbuild.

El siguiente perfil de publicación de carpeta se creó con Visual Studio y se publica en un recurso compartido de red:

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

En el ejemplo anterior:

  • La propiedad <ExcludeApp_Data> está presente simplemente para satisfacer un requisito de esquema XML. La propiedad <ExcludeApp_Data> no tiene ningún efecto en el proceso de publicación, aunque haya una carpeta App_Data en la raíz del proyecto. La carpeta App_Data no recibe un tratamiento especial, como sí sucede en los proyectos de ASP.NET 4.x.
  • La propiedad <LastUsedBuildConfiguration> se establece en Release. Al efectuar una publicación en Visual Studio, el valor de <LastUsedBuildConfiguration> se establece con el valor cuando se inicia el proceso de publicación. <LastUsedBuildConfiguration> es especial y no se debe reemplazar en un archivo importado de MSBuild. Sin embargo, esta propiedad se puede invalidar desde la línea de comandos mediante uno de los métodos siguientes.

    • Con la CLI de .NET Core:

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

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

    • Con MSBuild:

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

Publicar en un punto de conexión de MSDeploy desde la línea de comandos

En el ejemplo siguiente se utiliza una aplicación web ASP.NET Core de ejemplo creada mediante Visual Studio y denominada AzureWebApp. Se agrega un perfil de publicación de aplicaciones de Azure con Visual Studio. Para obtener más información sobre cómo crear un perfil, consulte la sección Perfiles de publicación.

Para implementar la aplicación con un perfil de publicación, ejecute el comando msbuild desde un símbolo del sistema para desarrolladores de Visual Studio. El símbolo del sistema se encuentra disponible en la carpeta Visual Studio del menú Inicio, en la barra de tareas de Windows. Para facilitar el acceso, puede agregar el símbolo del sistema al menú Herramientas de Visual Studio. Para más información, consulte Símbolo del sistema para desarrolladores de Visual Studio.

MSBuild usa la sintaxis de comando siguiente:

msbuild {PATH} 
    /p:DeployOnBuild=true 
    /p:PublishProfile={PROFILE} 
    /p:Username={USERNAME} 
    /p:Password={PASSWORD}
  • {PATH}: ruta de acceso al archivo de proyecto de la aplicación.
  • {PROFILE}: nombre del perfil de publicación.
  • {USERNAME}: nombre de usuario de MSDeploy. {USERNAME} está en el perfil de publicación.
  • {PASSWORD}: contraseña de MSDeploy. Obtenga el valor {PASSWORD} en el archivo {PROFILE}.PublishSettings. Descargue el archivo .PublishSettings desde:
    • Explorador de soluciones: Seleccione Ver>Cloud Explorer. Conéctese con su suscripción de Azure. Abra App Services. Haga clic con el botón derecho en la aplicación. Seleccione Descargar perfil de publicación.
    • Azure Portal: Haga clic en Obtener perfil de publicación, en el panel Información general de la aplicación web.

En el ejemplo siguiente se usa un perfil de publicación denominado AzureWebApp - Web Deploy:

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

También se puede usar un perfil de publicación ejecutando el comando dotnet msbuild de la CLI de .NET Core en un shell de comandos de Windows:

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

Importante

El comando dotnet msbuild es multiplataforma y permite compilar aplicaciones ASP.NET Core en macOS y Linux. Sin embargo, MSBuild en macOS y Linux no permite implementar una aplicación en Azure ni en otros puntos de conexión de MSDeploy.

Establecimiento del entorno

Incluya la propiedad <EnvironmentName> en el perfil de publicación ( .pubxml) o el archivo del proyecto para configurar el entorno de la aplicación:

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

Si necesita transformaciones de web.config (por ejemplo, establecer variables de entorno basadas en la configuración, el perfil o el entorno), vea Transformación de web.config.

Archivos de exclusión

Al publicar aplicaciones web de ASP.NET Core, se incluyen los siguientes recursos:

  • Artefactos de compilación
  • Las carpetas y archivos que coinciden con los siguientes patrones globales de uso:
    • **\*.config (por ejemplo, web.config)
    • **\*.json (por ejemplo, appsettings.json)
    • wwwroot\**

MSBuild admite los patrones globales. Por ejemplo, el siguiente elemento <Content> suprime la copia de los archivos de texto ( .txt) de la carpeta wwwroot/content y de sus subcarpetas:

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

El marcado anterior se puede agregar a un perfil de publicación o al archivo .csproj. Si se agrega al archivo .csproj, la regla se agrega a todos los perfiles de publicación del proyecto.

El siguiente elemento <MsDeploySkipRules> excluye todos los archivos de la carpeta wwwroot/content:

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

<MsDeploySkipRules> no eliminará del sitio de implementación los destinos skip. Los archivos y carpetas destinados a <Content> se eliminan del sitio de implementación. Por ejemplo, suponga que una aplicación web implementada tenía los siguientes archivos:

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

Si se agregan los siguientes elementos <MsDeploySkipRules>, esos archivos no se eliminarán en el sitio de implementación.

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

Los elementos <MsDeploySkipRules> anteriores impiden que se implementen los archivos omitidos. Una vez que se implementan esos archivos, no se eliminarán.

El siguiente elemento <Content> elimina los archivos de destino en el sitio de implementación:

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

El uso de la implementación de línea de comandos con el elemento <Content> anterior produce una variación de la siguiente salida:

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

Archivos de inclusión

En la siguientes secciones se describen diferentes enfoques para la inclusión de archivos en el momento de la publicación. En la sección Inclusión de archivos general se usa el elemento DotNetPublishFiles, que se proporciona mediante un archivo de destinos de publicación en el SDK web. En la sección Inclusión de archivos selectiva se usa el elemento ResolvedFileToPublish, que se proporciona mediante un archivo de destinos de publicación en el SDK de .NET Core. Dado que el SDK web depende del SDK de .NET Core, se puede usar cualquier elemento en un proyecto de ASP.NET Core.

Inclusión de archivos general

En el siguiente ejemplo, en el elemento <ItemGroup> se muestra cómo copiar una carpeta que se encuentra fuera del directorio del proyecto en una carpeta del sitio publicado. Los archivos agregados al elemento <ItemGroup> del marcado siguiente se incluyen de forma predeterminada.

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

El marcado anterior:

  • Se puede agregar al archivo .csproj o al perfil de publicación. Si se agrega al archivo .csproj, se incluye en todos los perfiles de publicación del proyecto.
  • Declara un elemento _CustomFiles para almacenar los archivos coincidentes con el patrón global del atributo Include. La carpeta images a la que se hace referencia en el patrón se encuentra fuera del directorio del proyecto. Una propiedad reservada, denominada $(MSBuildProjectDirectory), se resuelve en la ruta de acceso absoluta del archivo de proyecto.
  • Proporciona una lista de los archivos para el elemento DotNetPublishFiles. El elemento <DestinationRelativePath> de la lista aparece vacío de forma predeterminada. El valor predeterminado se reemplaza en el marcado y usa metadatos de elementos conocidos como %(RecursiveDir). El texto interno representa la carpeta wwwroot/images del sitio publicado.

Inclusión de archivos selectiva

En el marcado resaltado del siguiente ejemplo se muestra lo siguiente:

  • La copia un archivo que se encuentra fuera del proyecto en la carpeta wwwroot del sitio publicado. Se mantiene el nombre del archivo ReadMe2.md.
  • La exclusión de la carpeta wwwroot\Content.
  • La exclusión de 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>

En el ejemplo anterior se usa el elemento ResolvedFileToPublish, cuyo comportamiento predeterminado consiste siempre en copiar los archivos proporcionados en el atributo Include en el sitio publicado. Invalide el comportamiento predeterminado mediante la inclusión de un elemento secundario <CopyToPublishDirectory> con el texto interno de Never o PreserveNewest. Por ejemplo:

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

Para ver más ejemplos de implementación, consulte el archivo Léame del repositorio de WebSDK.

Ejecutar un destino antes o después de la publicación

Los destinos BeforePublish y AfterPublish ejecutan un destino antes o después del destino de publicación. Agregue los siguientes elementos al perfil de publicación para registrar mensajes de la consola antes y después de la publicación:

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

Publicación en un servidor mediante un certificado que no es de confianza

Agregue la propiedad <AllowUntrustedCertificate> con un valor de True al perfil de publicación:

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

Servicio Kudu

Para ver los archivos de la implementación de una aplicación web de Azure App Service, use el servicio Kudu. Anexe el token scm al nombre de la aplicación web. Por ejemplo:

Resolución Resultado
http://mysite.azurewebsites.net/ Aplicación web
http://mysite.scm.azurewebsites.net/ Servicio Kudu

Seleccione el elemento de menú Consola de depuración para ver, editar, eliminar o agregar archivos.

Recursos adicionales