Compilación, prueba e implementación de aplicaciones de .NET Core

Azure DevOps Services | Azure DevOps Server 2022 | Azure DevOps Server 2019

Use una canalización de Azure para compilar, probar e implementar automáticamente los proyectos de .NET Core. En este artículo se muestra cómo realizar las tareas siguientes:

• Configure el entorno de compilación con agentes hospedados por Microsoft o autohospedados.
• Restaure las dependencias, compile el proyecto y pruébelo con la tarea (DotNetCoreCLI@2) de .NET Core o un script.
• Pruebe el código y use la tarea de publicación de cobertura de código para publicar los resultados de la cobertura de código.
• Empaquete y entregue la salida de compilación a:
  • su tubería.
  • Una fuente de NuGet
  • .zipUn archivo para implementar una aplicación web en Azure

Nota:

Para obtener ayuda con proyectos de .NET Framework, consulte Compilación de aplicaciones ASP.NET con .NET Framework.

Requisitos previos

• Una cuenta de GitHub en la que pueda crear un repositorio. cree una de forma gratuita.
• Una organización y proyecto de Azure DevOps. cree una de forma gratuita.
• Tener capacidad para ejecutar canalizaciones en agentes hospedados por Microsoft. Puede comprar un trabajo paralelo o solicitar un nivel gratuito.

Cree su primera canalización

¿No está familiarizado con Azure Pipelines? Si es así, se recomienda probar primero la sección siguiente.

Creación de un proyecto de .NET

Si no tiene un proyecto de .NET con el que trabajar, cree uno nuevo en el sistema local. Empiece por instalar el SDK de .NET 8.0 más reciente.

1. Abra una ventana de terminal.

2. Cree un directorio de proyecto y vaya a él.

3. Cree una nueva aplicación web de .NET 8.

   dotnet new webapp -f net8.0
   

4. Desde la misma sesión de terminal, ejecute la aplicación localmente con el comando dotnet run desde el directorio del proyecto.

   dotnet run
   

5. Una vez que la aplicación se haya iniciado, presione Ctrl-C para cerrarla.

Creación de un repositorio de Git y conexión a GitHub

1. En el directorio del proyecto, crea un repositorio de Git local y confirma el código de aplicación en la rama principal.

2. Conectar un repositorio de Git local a un repositorio de GitHub.

Crear un proyecto de DevOps

Inicie sesión en Azure Pipelines. Una vez que haya iniciado sesión, el explorador accederá a https://dev.azure.com/my-organization-name y aparecerá el panel de Azure DevOps.

1. En un explorador, vaya a dev.azure.com e inicie sesión.
2. Seleccione su organización.
3. Para crear un nuevo proyecto, seleccione Nuevo proyecto o Crear proyecto si va a crear el primer proyecto de la organización.
4. Escriba un nombre de proyecto.
5. Seleccione la visibilidad del proyecto.
6. Seleccione Crear.

1. En un explorador, vaya a Azure DevOps Server.
2. Seleccione la colección.
3. Para crear un nuevo proyecto, seleccione Nuevo proyecto o Crear proyecto si va a crear el primer proyecto de la colección.
4. Escriba un nombre de proyecto.
5. Seleccione la visibilidad del proyecto.
6. Seleccione Crear.

Configure su entorno de compilación

Las compilaciones se ejecutan en Agentes hospedados en Microsoft. Puede compilar los proyectos de .NET Core mediante el SDK y el entorno de ejecución de .NET Core en Windows, Linux , macOS.

Como alternativa, puede usar un agente autohospedado. Con un agente autohospedado, puede usar SDK privados o de versión preliminar no admitidos oficialmente por Azure DevOps Services y ejecutar compilaciones incrementales.

Cree la canalización

Puede usar el editor de canalización YAML o el editor clásico para crear la canalización. Para usar el editor clásico, seleccione Usar el editor clásico.

YAML

Cree una canalización y seleccione el origen.

1. Inicie sesión en su organización de Azure DevOps y vaya a su proyecto.

2. Ve a Canalizaciones y selecciona Nueva canalización o Crear canalización si vas a crear tu primera canalización.

3. Siga los pasos del asistente y seleccione primero GitHub como ubicación del código fuente.

4. Puede que se le redirija a GitHub para iniciar sesión. Si es así, escriba sus credenciales de GitHub.

5. Cuando vea la lista de repositorios, seleccione el repositorio.

6. Es posible que se le redirija a GitHub para instalar la aplicación Azure Pipelines. Si es así, seleccione Aprobar e instalar.

Configuración de la canalización

1. Cuando aparezca la pestaña Configurar , seleccione Mostrar más y seleccione la plantilla de canalización principal ASP.NET de la lista.

2. Examine la nueva canalización para ver lo que hace YAML.

Puede personalizar el archivo YAML según sus propios requisitos. Por ejemplo, puede especificar el grupo de agentes o agregar una tarea para instalar otro SDK de .NET.

Guarde y ejecute la canalización

1. Cuando esté listo, seleccione Guardar y ejecutar.

   

2. Opcionalmente, puede editar el mensaje de confirmación.

3. Confirme el nuevo archivo azure-pipelines.yml en el repositorio seleccionando Guardar y ejecutar.

4. Para ver la canalización en acción, seleccione el trabajo en la sección Trabajos .

Clásico

Siga estos pasos para crear la canalización mediante el editor clásico.

Creación de una canalización

1. Vaya a su proyecto y seleccione Canalizaciones.

2. Seleccione Crear canalización Nueva canalización si no es la primera canalización del proyecto.

3. Seleccione Usar el editor clásico.

Seleccione su fuente

1. Seleccione su fuente. En este ejemplo, seleccione GitHub.
2. Escriba las credenciales de GitHub para crear una conexión de servicio de GitHub que se usará en la canalización.
3. Seleccione el repositorio y seleccione Continuar.

Configuración de la canalización

1. En Seleccionar una plantilla, busque y seleccione ASP.NET Core.

   La página de canalización se abre donde puede configurar la canalización. Aquí puede agregar tareas, especificar los grupos de agentes y agentes y configurar otras opciones de compilación.

2. En la pestaña Tareas , seleccione el grupo de agentes (normalmente predeterminado)

3. Seleccione la Especificación del agente. En este ejemplo, seleccione windows-latest.

   Para agregar otras tareas al trabajo del Agente, seleccione + en el trabajo del agente y seleccione otra tarea en el catálogo. Por ejemplo, puede agregar la tarea Usar .NET Core como primera tarea para instalar la versión necesaria del SDK de .NET.

Guarde y ejecute la canalización

1. &Seleccione Guardar y poner en cola en la lista desplegable Guardar, poner en cola de la parte superior de la página.
2. En Ejecutar canalización, escriba un comentario y seleccione Guardar y ejecutar.

Para ver la canalización en acción, seleccione el trabajo en la sección Trabajos de la pestaña Resumen .

Ahora tiene una canalización que funciona que está lista para que la personalice. Obtenga más información sobre algunas de las formas comunes de personalizar la canalización.

Entorno de compilación

Puede usar Azure Pipelines para compilar los proyectos de .NET Core en Windows, Linux o macOS sin necesidad de configurar la infraestructura.

Por ejemplo, Ubuntu se establece aquí en el archivo YAML de canalización.

pool:
  vmImage: 'ubuntu-latest' 

Consulte Agentes hospedados por Microsoft para obtener una lista completa de imágenes y más ejemplos de configuración.

Los agentes hospedados por Microsoft en Azure Pipelines incluyen varias versiones preinstaladas de los SDK de .NET Core compatibles. Los agentes hospedados por Microsoft no incluyen algunas de las versiones anteriores del SDK de .NET Core. Normalmente, no incluyen versiones preliminares. Si necesita estas versiones del SDK en agentes hospedados por Microsoft, instálelas mediante la tarea UseDotNet@2 .

Por ejemplo, para instalar el SDK 5.0.x, agregue el siguiente fragmento:

steps:
- task: UseDotNet@2
  inputs:
    version: '5.x'

Los agentes de Windows ya incluyen un entorno de ejecución de .NET Core. Para instalar un SDK más reciente, establezca performMultiLevelLookup en true en el siguiente fragmento de código:

steps:
- task: UseDotNet@2
  displayName: 'Install .NET Core SDK'
  inputs:
    version: 8.x
    performMultiLevelLookup: true
    includePreviewVersions: true # Required for preview versions

Sugerencia

Para ahorrar el costo de ejecutar el instalador de herramientas, puede configurar un agente autohospedado de Linux, macOS o Windows. También puede usar agentes autohospedados para ahorrar más tiempo si tiene un repositorio grande o puede ejecutar compilaciones incrementales. Un agente autohospedado también puede ayudarle a usar la versión preliminar o los SDK privados que no son compatibles oficialmente con Azure DevOps o que solo están disponibles en los entornos corporativos o locales.

Restauración de dependencias

NuGet es una manera popular de depender del código que no se compila. Puede descargar paquetes NuGet y herramientas específicas del proyecto que se especifican en el archivo de proyecto mediante la ejecución del comando dotnet restore a través de la tarea de .NET Core o directamente en un script de la canalización. Para obtener más información, consulte Tarea de .NET Core (DotNetCoreCLI@2).

Puede descargar paquetes NuGet desde Azure Artifacts, NuGet.org u otro repositorio NuGet externo o interno. La tarea de .NET Core es especialmente útil para restaurar paquetes a partir de fuentes NuGet autenticadas. Si la fuente está en el mismo proyecto que la canalización, no es necesario autenticarse.

Esta canalización usa una fuente de artefactos de Azure para dotnet restore en la tarea DotNetCoreCLI@2 .

trigger:
- main

pool:
  vmImage: 'windows-latest'

steps:
- task: UseDotNet@2
  displayName: 'Install .NET Core SDK'
  inputs:
    version: 8.x
    performMultiLevelLookup: true
    includePreviewVersions: true # Required for preview versions

variables:
  buildConfiguration: 'Release'

steps:
- task: DotNetCoreCLI@2
  inputs:
    command: 'restore'
    feedsToUse: 'select'
    vstsFeed: 'my-vsts-feed' # A series of numbers and letters

- task: DotNetCoreCLI@2
  inputs:
    command: 'build'
    arguments: '--configuration $(buildConfiguration)'
  displayName: 'dotnet build $(buildConfiguration)'

El dotnet restore comando usa el NuGet.exe empaquetado con el SDK de .NET Core y solo puede restaurar paquetes especificados en los archivos de proyecto .csproj de .NET Core.

Si también tiene un proyecto de Microsoft .NET Framework en la solución o usa package.json para especificar las dependencias, use la tarea NuGet para restaurar esas dependencias.

- task: NuGetCommand@2
  inputs:
    command: 'restore'
    restoreSolution: '**/*.sln'
    feedsToUse: 'select'

En la versión 2.0 y posteriores del SDK de .NET Core, los paquetes se restauran automáticamente al ejecutar comandos como dotnet build. Sin embargo, aún tendría que usar la tarea de .NET Core para restaurar paquetes si usa una fuente autenticada.

Las compilaciones pueden fallar debido a problemas de conexión al restaurar paquetes desde NuGet.org. Puede usar Azure Artifacts con orígenes ascendentes para almacenar en caché los paquetes. Las credenciales de la canalización se usan automáticamente cuando se conecta a Azure Artifacts. Estas credenciales se derivan normalmente de la cuenta de servicio de compilación de recopilación de proyectos. Para más información sobre el uso de Azure Artifacts para almacenar en caché los paquetes NuGet, consulte Conectar a fuentes de Azure Artifact.

Para especificar un repositorio NuGet, coloque la dirección URL en un NuGet.config archivo del repositorio. Si la fuente está autenticada, administre sus credenciales mediante la creación de una conexión de servicio NuGet en la pestaña Servicios en Configuración del proyecto.

Cuando se usan agentes hospedados por Microsoft, se obtiene una nueva máquina cada vez que se ejecuta una compilación, que restaura los paquetes con cada ejecución. La restauración puede tardar bastante tiempo. Para mitigarlo, puede usar Azure Artifacts o un agente autohospedado con la ventaja de usar la caché de paquetes.

Para obtener más información sobre las conexiones de servicio NuGet, consulte Publicar en fuentes de NuGet.

Restauración de paquetes desde una fuente externa

Haga lo siguiente para restaurar paquetes desde una fuente externa.

YAML

Puede agregar el comando restore a la canalización mediante el editor de canalizaciones DE YAML insertando directamente el siguiente fragmento de código en azure-pipelines.yml el archivo o usando la tarea asistente para agregar la tarea de .NET Core.

# do this before your build tasks
steps:
- task: DotNetCoreCLI@2
  displayName: Restore
  inputs:
    command: restore
    projects: '**/*.csproj'
    feedsToUse: config
    nugetConfigPath: NuGet.config    # Relative to root of the repository
    externalFeedCredentials: <Name of the NuGet service connection>

Reemplace el marcador <de posición por el nombre de la conexión de> servicio.

Para usar el asistente de tareas:

Para agregar una tarea de compilación mediante la tarea asistente, siga estos pasos:

1. Vaya a la posición en el archivo YAML donde desea insertar la tarea.

2. Seleccione . NET Core en el catálogo de tareas.

3. Seleccione el comando de restauración en la lista desplegable Comando .

4. En el campo Ruta de acceso a proyectos , escriba la ruta de acceso a los .csproj archivos.

5. Seleccione Agregar.

6. Seleccione Guardar para confirmar el cambio.

Clásico

Siga estos pasos para agregar una tarea de restauración mediante el editor clásico:

1. Seleccione Tareas en la canalización y seleccione el trabajo que ejecuta las tareas de compilación.

2. Seleccione + esta opción para agregar una nueva tarea a ese trabajo.

3. En el catálogo de tareas, busque y seleccione Tarea de .NET Core y seleccione Agregar .

4. Seleccione la tarea para abrir el editor de tareas.

5. Seleccione restaurar en la lista Comandos y especifique las demás opciones que necesite para esta tarea.

6. En la lista de tareas, arrastre la tarea para colocarla antes de la tarea de compilación.

7. &En la lista desplegable Guardar y cola , seleccione una opción para guardar el cambio.

Nota:

Asegúrese de que la fuente personalizada se especifica en el archivo NuGet.config y de que las credenciales se especifican en la conexión del servicio NuGet.

Compilación del proyecto

Compile los proyectos de .NET Core mediante la ejecución del dotnet build comando . Puede agregar el comando a la canalización como un script de línea de comandos o mediante la tarea .NET Core.

Compilación de .NET Core mediante la tarea .NET Core

Ejemplo de YAML para compilar mediante la tarea DotNetCoreCLI@2:

steps:
- task: DotNetCoreCLI@2
  displayName: Build
  inputs:
    command: build
    projects: '**/*.csproj'
    arguments: '--configuration $(buildConfiguration)' # Update this to match your needs

YAML

Puede agregar una tarea de compilación mediante el editor de canalizaciones de YAML editando directamente el archivo o agregando la tarea de .NET Core mediante la tarea asistente.

Para agregar una tarea de compilación mediante la tarea asistente, siga estos pasos:

1. Vaya a la posición en el archivo YAML donde desea insertar la tarea.

2. Seleccione . NET Core en el catálogo de tareas.

3. Seleccione el comando de compilación en la lista desplegable Comando .

4. En el campo Ruta de acceso a proyectos , escriba la ruta de acceso a los .csproj archivos.

5. Seleccione Agregar.

6. Seleccione Guardar para confirmar el cambio.

Clásico

Para agregar una tarea de compilación mediante el editor clásico, siga estos pasos:

1. Seleccione Tareas en la canalización.

2. Seleccione el trabajo que ejecuta las tareas de compilación.

3. Seleccione + esta opción para agregar una nueva tarea a ese trabajo.

4. En el catálogo de tareas, busque y agregue la tarea de .NET Core.

5. Seleccione la tarea y seleccione Compilar en la lista desplegable Comando .

6. En el campo Ruta de acceso a proyectos , escriba la ruta de acceso a los .csproj archivos.

7. Arrastre la tarea para colocarla en la secuencia de tareas correcta de la canalización.

8. Seleccione la lista desplegable Guardar y cola y seleccione una opción para guardar los cambios.

Compilación de .NET Core mediante script de línea de comandos

Ejemplo de YAML para compilar con dotnet build como script:

steps:
- script: dotnet build --configuration $(buildConfiguration)
  displayName: 'dotnet build $(buildConfiguration)'

YAML

Puede agregar una tarea de compilación mediante el editor de canalizaciones de YAML editando directamente el archivo o agregando la tarea Línea de comandos.

Siga estos pasos para agregar la tarea de línea de comandos:

1. Vaya a la posición en el archivo YAML donde desea insertar la tarea.

2. Seleccione la línea de comandos en el catálogo de tareas.

3. Opcionalmente, agregue un nombre para mostrar.

4. Escriba el dotnet build comando con parámetros. Por ejemplo, dotnet build --configuration $(buildConfiguration).

5. Escriba la ruta de acceso al .csproj archivo como directorio de trabajo.

6. Seleccione Agregar.

7. Seleccione Guardar para confirmar el cambio.

Clásico

Para agregar una tarea de compilación mediante el editor clásico, siga estos pasos:

1. Seleccione Tareas en la canalización.

2. Seleccione el trabajo que ejecuta las tareas de compilación.

3. Seleccione + esta opción para agregar una nueva tarea a ese trabajo.

4. En el catálogo de tareas, busque y agregue la tarea Línea de comandos.

5. Opcionalmente, agregue un nombre para mostrar.

6. Escriba el dotnet build comando con parámetros. Por ejemplo, dotnet build --configuration $(buildConfiguration).

7. Escriba la ruta de acceso al .csproj archivo como directorio de trabajo.

8. Arrastre la tarea para colocarla en la secuencia de tareas correcta de la canalización.

9. Seleccione la lista desplegable Guardar y cola y seleccione una opción para guardar los cambios.

Adición de comandos del SDK de .NET a la canalización

Puede agregar comandos del SDK de .NET al proyecto como script o mediante la tarea de .NET Core. La tarea de tarea .NET Core (DotNetCoreCLI@2) permite agregar fácilmente comandos de la CLI de dotnet a la canalización. Puede agregar tareas de .NET Core editando el archivo YAML o usando el editor clásico.

Adición de un comando de la CLI de .NET mediante la tarea de .NET Core

YAML

Para agregar un comando de la CLI de .NET Core mediante el editor de canalizaciones de YAML, siga estos pasos:

1. Vaya a la posición en el archivo YAML donde desea insertar la tarea.

2. Seleccione NET Core en el catálogo de tareas.

3. Seleccione el Comando que quieres ejecutar.

4. Configure las opciones necesarias.

5. Seleccione Agregar.

6. Seleccione Guardar para confirmar el cambio.

Clásico

Para agregar la tarea de .NET Core mediante el editor clásico, siga estos pasos:

1. Seleccione Tareas en la canalización.

2. Seleccione el trabajo que ejecuta las tareas de compilación.

3. Seleccione + esta opción para agregar una nueva tarea a ese trabajo.

4. En el catálogo de tareas, busque y agregue la tarea de .NET Core.

5. Seleccione la tarea y seleccione el comando que desea ejecutar.

6. Configure las opciones necesarias.

7. Arrastre la tarea para colocarla en la secuencia de tareas correcta de la canalización.

8. En la lista desplegable Guardar y cola , seleccione una opción para guardar los cambios.

Adición de un comando de la CLI de .NET Core mediante un script

Puede agregar comandos de la CLI de .NET Core como en script el azure-pipelines.yml archivo.

Ejemplo:

steps:
# ...
- script: dotnet test <test-project> 

Instalación de una herramienta

Para instalar una herramienta global de .NET Core como dotnetsay en la compilación que se ejecuta en Windows, siga estos pasos:

1. Agrega la tarea .NET Core y establece las siguientes propiedades:
   • Comando: personalizado
     • Ruta de acceso a los proyectos: déjelo vacío
   • Comando personalizado: herramienta
   • Argumentos: install -g dotnetsay
2. Para ejecutar la herramienta, agregue una línea de comandos y establezca las siguientes propiedades:
   • Script: dotnetsay.

Ejecutar las pruebas

Cuando tenga proyectos de prueba en el repositorio, puede usar la tarea de .NET Core para ejecutar pruebas unitarias mediante marcos de pruebas como MSTest, xUnit y NUnit. El proyecto de prueba debe hacer referencia a la versión 15.8.0 o posterior de Microsoft.NET.Test.SDK. Los resultados de las pruebas se publican automáticamente en el servicio. Estos resultados están disponibles en el resumen de compilación y se pueden usar para solucionar errores de pruebas y análisis de tiempo de prueba.

Puede agregar una tarea de prueba a la canalización mediante la tarea DotNetCoreCLI@2 o agregar el siguiente fragmento de código al azure-pipelines.yml archivo:

steps:
# ...
# do this after other tasks such as building
- task: DotNetCoreCLI@2
  inputs:
    command: test
    projects: '**/*Tests/*.csproj'
    arguments: '--configuration $(buildConfiguration)'

Al usar el editor de tareas de .NET Core , establezca Comando para probar y Ruta de acceso a los proyectos debe hacer referencia a los proyectos de prueba de la solución.

Como alternativa, puede ejecutar el dotnet test comando con un registrador específico y, a continuación, utilizar la tarea Publicar resultados de pruebas :

steps:
# ...
# do this after your tests have run
- script: dotnet test <test-project> --logger trx
- task: PublishTestResults@2
  condition: succeededOrFailed()
  inputs:
    testRunner: VSTest
    testResultsFiles: '**/*.trx'

Recopilar cobertura de código

Al compilar en la plataforma Windows, las métricas de cobertura de código se pueden recopilar mediante el recopilador de datos de cobertura integrado. El proyecto de prueba debe hacer referencia a la versión 15.8.0 o posterior de Microsoft.NET.Test.SDK.

Cuando se usa la tarea .NET Core para ejecutar pruebas, los datos de cobertura se publican automáticamente en el servidor. El .coverage archivo se puede descargar desde el resumen de compilación para verlo en Visual Studio.

Agregue el siguiente fragmento de código a su archivo azure-pipelines.yml:

steps:
# ...
# do this after other tasks such as building
- task: DotNetCoreCLI@2
  inputs:
    command: test
    projects: '**/*Tests/*.csproj'
    arguments: '--configuration $(buildConfiguration) --collect "Code coverage"'

Para agregar la tarea de .NET Core a través del editor de tareas:

1. Agregue la tarea de .NET Core al trabajo de compilación y establezca las siguientes propiedades:

   1. Comando: prueba
   2. La ruta de acceso a los proyectos: debe hacer referencia a los proyectos de prueba de la solución
   3. Argumentos: --configuration $(BuildConfiguration) --collect "Code coverage"

2. Asegúrese de que la opción Publicar resultados de pruebas permanece seleccionada.

Si decide ejecutar el comando dotnet test, especifique las opciones de registrador y cobertura de los resultados de la prueba. A continuación, use la tarea Publicar resultados de pruebas:

steps:
# ...
# do this after your tests have run
- script: dotnet test <test-project> --logger trx --collect "Code coverage"
- task: PublishTestResults@2
  inputs:
    testRunner: VSTest
    testResultsFiles: '**/*.trx'

Recopilación de métricas de cobertura de código con Coverlet

Si va a compilar en Linux o macOS, puede usar Coverlet o una herramienta similar para recopilar métricas de cobertura de código.

Puede publicar los resultados de la cobertura de código en el servidor con la tarea Publicar resultados de cobertura de código (PublishCodeCoverageResults@1). La herramienta de cobertura debe configurarse para generar resultados en formato Cobertura o JaCoCo.

Para ejecutar pruebas y publicar la cobertura de código con Coverlet, realice las siguientes tareas:

• Agregue una referencia al paquete NuGet coverlet.collector.

• Agregue el siguiente fragmento de código a su archivo azure-pipelines.yml:

  - task: UseDotNet@2
    inputs:
      version: '8.x'
      includePreviewVersions: true # Required for preview versions
  
  - task: DotNetCoreCLI@2
    displayName: 'dotnet build'
    inputs:
      command: 'build'
      configuration: $(buildConfiguration)
  
  - task: DotNetCoreCLI@2
    displayName: 'dotnet test'
    inputs:
      command: 'test'
      arguments: '--configuration $(buildConfiguration) --collect:"XPlat Code Coverage" -- DataCollectionRunSettings.DataCollectors.DataCollector.Configuration.Format=cobertura'
      publishTestResults: true
      projects: 'MyTestLibrary' # update with your test project directory
  
  - task: PublishCodeCoverageResults@1
    displayName: 'Publish code coverage report'
    inputs:
      codeCoverageTool: 'Cobertura'
      summaryFileLocation: '$(Agent.TempDirectory)/**/coverage.cobertura.xml'
  

Empaquetado y entrega del código

Puede publicar los artefactos de compilación mediante:

• Publicación en Azure Pipelines.
• Publicación de paquetes en Azure Artifacts.
• Creación de un paquete NuGet y publicación en la fuente de NuGet.
• Creación de un archivo de .zip para implementar la aplicación web.

Publicación de artefactos en Azure Pipelines

Para publicar la salida de la compilación de .NET en la canalización, realice las siguientes tareas:

• Ejecute dotnet publish --output $(Build.ArtifactStagingDirectory) en la CLI de .NET o agregue la tarea DotNetCoreCLI@2 con el comando publish.
• Publique el artefacto mediante la tarea Publicar artefacto de canalización.

Agregue el siguiente fragmento de código al archivo azure-pipelines.yml:

steps:

- task: DotNetCoreCLI@2
  inputs:
    command: publish
    publishWebProjects: True
    arguments: '--configuration $(BuildConfiguration) --output $(Build.ArtifactStagingDirectory)'
    zipAfterPublish: True

# this code takes all the files in $(Build.ArtifactStagingDirectory) and uploads them as an artifact of your build.
- task: PublishPipelineArtifact@1
  inputs:
    targetPath: '$(Build.ArtifactStagingDirectory)' 
    artifactName: 'myWebsite'

Nota:

La tarea DotNetCoreCLI@2 tiene una publishWebProjects entrada que se establece en true de forma predeterminada. Esta tarea publica todos los proyectos web del repositorio de forma predeterminada. Puede encontrar más ayuda e información en la tarea de código abierto en GitHub.

Para copiar más archivos en el directorio de compilación antes de publicarlos, utilice la tarea Copiar archivos (CopyFile@2).

Publicación en una fuente de NuGet

Para crear un paquete NuGet y publicarlo en la fuente NuGet, agregue el siguiente fragmento de código:

steps:
# ...
# do this near the end of your pipeline in most cases
- script: dotnet pack /p:PackageVersion=$(version)  # define version variable elsewhere in your pipeline
- task: NuGetAuthenticate@1
  inputs:
    nuGetServiceConnections: '<Name of the NuGet service connection>'
- task: NuGetCommand@2
  inputs:
    command: push
    nuGetFeedType: external
    publishFeedCredentials: '<Name of the NuGet service connection>'
    versioningScheme: byEnvVar
    versionEnvVar: version

Nota:

La tarea NuGetAuthenticate@1 no admite la autenticación de clave de API de NuGet. Si usa una clave de API de NuGet, use la tarea NuGetCommand@2 con la command entrada establecida push en con el argumento --api-key . Por ejemplo, dotnet nuget push --api-key $(NuGetApiKey).

Para obtener más información sobre el control de versiones y la publicación de paquetes NuGet, consulte Publicar en fuentes de NuGet.

Publicación de un paquete NuGet en Azure Artifacts

Puede publicar los paquetes NuGet en la fuente de Azure Artifacts mediante el NuGetCommand@2 para insertarlos en la fuente de Azure Artifact. Por ejemplo, consulte Publicación de paquetes NuGet con Azure Pipelines.

Implementación de una aplicación web

Para crear un archivo .zip que esté listo para publicarse en una aplicación web, agregue el siguiente fragmento de código:

steps:
# ...
# do this after you've built your app, near the end of your pipeline in most cases
# for example, you do this before you deploy to an Azure web app on Windows
- task: DotNetCoreCLI@2
  inputs:
    command: publish
    publishWebProjects: True
    arguments: '--configuration $(BuildConfiguration) --output $(Build.ArtifactStagingDirectory)'
    zipAfterPublish: True

Para publicar este archivo en una aplicación web, consulte Implementación de Azure Web Apps.

Compilar e insertar imágenes en un registro de contenedor

También puede compilar una imagen para la aplicación e insertarla en un registro de contenedor.

Publicación de símbolos

Puede usar la tarea PublishSymbols@2 para publicar símbolos en un servidor de símbolos de Azure Artifacts o en un recurso compartido de archivos.

Por ejemplo, para publicar símbolos en un recurso compartido de archivos, añada el siguiente fragmento de código al archivo azure-pipelines.yml:

- task: PublishSymbols@2
  inputs:
    SymbolsFolder: '$(Build.SourcesDirectory)'
    SearchPattern: '**/bin/**/*.pdb'
    IndexSources: true
    PublishSymbols: true
    SymbolServerType: 'FileShare' 
    SymbolsPath: '\\server\shareName'

Al usar el editor clásico, seleccione Indexar código fuente y publicar símbolos en el catálogo de tareas para añadirlo a la canalización.

Para más información, consulte Publicación de símbolos.

Solución de problemas

Si puede compilar el proyecto en el equipo de desarrollo pero tiene problemas para compilarlo en Azure Pipelines, explore las siguientes causas potenciales y acciones correctivas:

• Las versiones preliminares del SDK de .NET Core no están instaladas en los agentes hospedados por Microsoft. Una vez publicada una nueva versión del SDK de .NET Core, puede tardar unas semanas en implementarse en todos los centros de datos de Azure Pipelines. No es necesario esperar a que se complete el lanzamiento. Puede usar la tarea Usar .NET Core para instalar la versión del SDK de .NET Core que desee en los agentes hospedados por Microsoft.

• Compruebe las versiones y el entorno de ejecución del SDK de .NET Core en el equipo de desarrollo y asegúrese de que coinciden con el agente. Puede incluir un script dotnet --version de línea de comandos en la canalización para imprimir la versión del SDK de .NET Core. Use el Instalador de herramientas de .NET Core para implementar la misma versión en el agente o actualice los proyectos y la máquina de desarrollo a la versión más reciente del SDK de .NET Core.

• Es posible que esté usando alguna lógica en el IDE de Visual Studio que no esté codificada en la canalización. Azure Pipelines ejecuta cada uno de los comandos que especifique en las tareas una después de la otra en un proceso nuevo. Examine los registros de la compilación de canalizaciones para ver los comandos exactos que se ejecutaron como parte de la compilación. Repita los mismos comandos en el mismo orden en la máquina de desarrollo para localizar el problema.

• Si tiene una solución que incluye algunos proyectos de .NET Core y algunos proyectos de .NET Framework, también debe usar la tarea NuGet para restaurar paquetes especificados en archivos packages.config. Agregue la tarea MSBuild o Visual Studio Build para compilar los proyectos de .NET Framework.

• Es posible que las compilaciones generen errores intermitentemente durante la restauración de paquetes. Esto significa que NuGet.org tiene problemas o que hay problemas de red entre el centro de datos de Azure y NuGet.org. Puedes averiguar si usar Azure Artifacts con NuGet.org como origen ascendente mejora la confiabilidad de las compilaciones, ya que no depende de nosotros.

• En ocasiones, cuando se implementa una nueva versión del SDK de .NET Core o Visual Studio, es posible que se interrumpa la compilación. Por ejemplo, si se incluye una versión o característica más reciente de la herramienta NuGet con el SDK, se podría interrumpir la compilación. Para aislar este problema, usa la tarea Instalador de herramientas de .NET Core para especificar la versión del SDK de .NET Core que se usa en la compilación.

Preguntas más frecuentes

P: ¿Dónde puedo obtener información sobre Azure Artifacts?

R: Administración de paquetes en Azure Artifacts

P: ¿Dónde se puede obtener más información sobre los comandos de .NET Core?

R: Herramientas de la CLI de .NET Core

P: ¿Dónde puedo obtener más información sobre la ejecución de pruebas en mi solución?

R: Pruebas unitarias en proyectos de .NET Core

P: ¿Dónde puedo obtener más información sobre tareas?

R: Tareas de compilación y versión