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

Azure DevOps Services | Azure DevOps Server | Azure DevOps Server 2022 | Azure DevOps Server 2020

En este artículo se describe cómo usar Azure Pipelines para trabajar con proyectos de .NET Core. El artículo le guía por las siguientes tareas:

• Cree una aplicación web de .NET Core y cárguelo en un repositorio de GitHub.
• Cree un proyecto de Azure DevOps y una canalización de Azure Pipelines para compilar el proyecto.
• Configure el entorno de compilación con agentes hospedados por Microsoft o autohospedados.
• Restaure las dependencias, compile el proyecto y pruebe con la tarea de .NET Core (DotNetCoreCLI@2) o un script.
• Use la tarea .NET Core (DotNetCoreCLI@2) para agregar otros comandos del SDK de .NET a la canalización.
• Use la tarea Publicar resultados de cobertura de código (Publish code coverage results v2) para publicar resultados de cobertura de código.
• Empaqueta y entrega la salida de compilación a la canalización, una fuente nuGet, un archivo ZIP u otros destinos.

Nota:

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

Requisitos previos

Para completar todos los procedimientos de este artículo, necesita los siguientes requisitos previos:

• Una organización de Azure DevOps. Puede crear una de forma gratuita.
• Pertenencia al grupo Administradores de proyectos de la organización, por lo que puede crear proyectos de Azure DevOps y conceder acceso al proyecto a las canalizaciones. Los propietarios de la organización de Azure DevOps tienen automáticamente esta pertenencia.
• Un proyecto de Azure DevOps en la organización. Cree un proyecto en Azure DevOps.
• La capacidad de ejecutar canalizaciones en agentes hospedados por Microsoft, solicitando un nivel gratuito de trabajos paralelos. Esta solicitud puede tardar varios días laborables en procesarse. Para obtener más información, consulte Configuración y pago de trabajos paralelos.
• El rol Administrador o Creador para las conexiones de servicio, que puede asignar como administrador de proyectos.
• Una cuenta y un repositorio de GitHub .

Creación de un proyecto de .NET y su carga en GitHub

Si desea usar un proyecto de .NET ya en el repositorio de GitHub, puede omitir esta sección.

Si no tiene un proyecto de .NET con el que trabajar, cree uno nuevo en el equipo local de la siguiente manera:

1. Instale el SDK de .NET 8.0 o asegúrese de que está instalado.
2. Abra una ventana de terminal en el equipo local.
3. Cree un directorio de proyecto y vaya a él.
4. Cree una aplicación web de .NET 8 mediante la ejecución dotnet new webapp -f net8.0de .
5. Compile y ejecute la aplicación localmente mediante dotnet run.
6. Cuando se inicie la aplicación, presione Ctrl+C para apagarla.
7. Cargue o conecte el proyecto local al repositorio de GitHub.

Creación de una canalización

Si tiene una canalización que desea usar, puede omitir esta sección. De lo contrario, puede usar el editor de canalizaciones YAML o el editor clásico para crear una canalización de la siguiente manera:

YAML

1. En el proyecto de Azure DevOps, seleccione Canalizaciones en el menú de navegación izquierdo.

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

3. En la pantalla Where is your code (Dónde está el código ), seleccione GitHub.

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

5. En la pantalla Seleccionar un repositorio , seleccione el repositorio en el que se encuentra la aplicación .NET.

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

7. En la pestaña Configurar , seleccione Mostrar más y, a continuación, seleccione la plantilla de canalización ASP.NET Core de la lista. Esta plantilla proporciona muchos de los pasos y la configuración que describe este artículo.

   También puede seleccionar Canalización de inicio en la pestaña Configurar para empezar con una canalización mínima y agregar los pasos y la configuración usted mismo.

8. En la pestaña Revisar , examine el código YAML. Puede personalizar el archivo para sus requisitos. Por ejemplo, puede especificar un grupo de agentes diferente o agregar una tarea para instalar otro SDK de .NET.

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

   

10. Opcionalmente, edite el mensaje Confirmar y, a continuación, seleccione Guardar y ejecutar de nuevo.

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

Clásico

1. En el proyecto de Azure DevOps, seleccione Canalizaciones en el menú de navegación izquierdo.

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

3. En la pantalla Where is your code (Dónde está el código ), seleccione Usar el editor clásico para crear una canalización sin YAML.

   Nota:

   La capacidad de crear canalizaciones clásicas está desactivada de forma predeterminada para las nuevas organizaciones y proyectos de Azure DevOps. Si no ve la opción de usar el editor clásico, desactive la opción Deshabilitar la creación de canalizaciones de compilación clásicas y Deshabilitar la creación de canalizaciones de versión clásicas en Configuración de>> configuración de la organización o Configuración decanalizaciones>de configuración> del proyecto.

4. En Seleccionar un origen, seleccione GitHub.

5. Proporcione un nombre de conexión y, a continuación, seleccione Autorizar mediante OAuth. También puede seleccionar autorizar con la aplicación gitHub de Azure Pipelines o un token de acceso personal (PAT) de GitHub.

6. Proporcione el nombre del repositorio de GitHub, incluida la organización o el usuario, y la rama predeterminada, normalmente principal.

7. Selecciona Continuar.

8. En la pantalla Seleccionar una plantilla , busque y seleccione la plantilla ASP.NET Core y, a continuación, seleccione Aplicar. Se abre la página de canalización, donde puede agregar tareas, especificar grupos de agentes y agentes y configurar otras opciones de compilación.

   La plantilla ASP.NET Core proporciona muchos de los pasos y la configuración que describe este artículo. También puede seleccionar Trabajo vacío para empezar con una canalización mínima y agregar las tareas y la configuración usted mismo.

9. En la pestaña Tareas , en Grupo de agentes, seleccione Azure Pipelines para usar agentes hospedados por Microsoft.

10. En Especificación del agente, seleccione Windows-latest para este ejemplo.

11. Seleccione Guardar y poner en cola>Guardar y poner en cola en la parte superior de la página.

12. En la pantalla Ejecutar canalización , escriba un comentario Guardar y, a continuación, seleccione Guardar y ejecutar.

13. Seleccione el trabajo en la sección Trabajos de la pestaña Resumen para ver la canalización en acción.

Para agregar tareas al trabajo del Agente 1 , seleccione + en el trabajo y seleccione una tarea de la lista. Por ejemplo, podría agregar la tarea Usar .NET Core como primera tarea para instalar el SDK de .NET.

Ahora tiene una canalización de trabajo lista para personalizarla.

Configure su entorno de compilación

Puede compilar los proyectos de .NET Core mediante el SDK y el entorno de ejecución de .NET Core para Windows, Linux o macOS. De forma predeterminada, las compilaciones se ejecutan en agentes hospedados por Microsoft, por lo que no es necesario configurar la infraestructura.

Los agentes hospedados por Microsoft de Azure Pipelines incluyen varias versiones preinstaladas de SDK de .NET Core compatibles. Consulte Agentes hospedados por Microsoft para obtener una lista completa de imágenes y ejemplos de configuración disponibles.

El siguiente fragmento de código de canalización de YAML establece el sistema operativo Ubuntu para el grupo de agentes.

pool:
  vmImage: 'ubuntu-latest' 

Los agentes hospedados por Microsoft no incluyen algunas versiones anteriores del SDK de .NET Core y normalmente no incluyen versiones preliminares. Si necesita estas versiones del SDK en agentes hospedados por Microsoft, puede instalarlas mediante la tarea Usar DotNet (UseDotNet@2).

Por ejemplo, el código siguiente instala el SDK de .NET 5.0.x:

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 performMultiLevelLookuptrue en como en el fragmento de código siguiente:

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

Agentes autohospedados

Como alternativa, puede usar agentes autohospedados para compilar los proyectos de .NET Core. Puede configurar agentes autohospedados de Linux, macOS o Windows .

Los agentes autohospedados le permiten:

• Evite el costo de ejecutar el UseDotNet@2 instalador de herramientas.
• Reduzca el tiempo de compilación si tiene un repositorio grande.
• Ejecute compilaciones incrementales.
• Use sdk privados o de versión preliminar que Microsoft no admite oficialmente.
• Use los SDK disponibles solo en los entornos corporativos o locales.

Para más información, consulte Agentes autohospedados.

Restauración de dependencias

Los paquetes NuGet son una manera de que el proyecto dependa del código que no compile. Puede descargar paquetes NuGet y herramientas específicas del proyecto ejecutando el dotnet restore comando, ya sea a través de la tarea .NET Core (DotNetCoreCLI@2) o como un script en la canalización. El dotnet restore comando usa el NuGet.exe empaquetado con el SDK de .NET Core y solo puede restaurar paquetes especificados en los archivos *.csproj del proyecto de .NET Core.

Puede usar la tarea de .NET Core (DotNetCoreCLI@2) para descargar y restaurar paquetes NuGet desde Azure Artifacts, NuGet.org u otro repositorio nuGet externo o interno autenticado. Si la fuente NuGet está en el mismo proyecto que la canalización, no es necesario autenticarse. Para obtener más información, consulte Tarea de .NET Core (DotNetCoreCLI@2).

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 mitigar este problema, use Azure Artifacts o un agente autohospedado para aprovechar la memoria caché del paquete.

La canalización siguiente usa la DotNetCoreCLI@2 tarea para restaurar una fuente de Azure Artifact.

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

En la versión 2.0 y posterior del SDK de .NET Core, los paquetes se restauran automáticamente cuando se ejecutan comandos como dotnet build. Todavía tiene que usar la tarea de .NET Core (DotNetCoreCLI@2) para restaurar paquetes si usa una fuente autenticada.

Administre las credenciales de una fuente autenticada mediante la creación de una conexión de servicio NuGet en lasconexiones del servicio>> proyecto. Para más información sobre las conexiones de servicio NuGet, consulte Publicación de paquetes NuGet con Azure Pipelines.

Restauración de paquetes desde NuGet.org

Para restaurar paquetes desde NuGet.org, actualice la canalización de la manera siguiente.

YAML

Puede agregar el comando restore a la canalización editando el código YAML directamente o mediante el asistente de tareas.

Agregue la tarea .NET Core (DotNetCoreCLI@2) directamente insertando el siguiente fragmento de código en el archivo azure-pipelines.yml antes de las tareas de compilación.

steps:
- task: DotNetCoreCLI@2
  displayName: Restore
  inputs:
    command: restore
    projects: '**/*.csproj'
    feedsToUse: select

Para usar el asistente de tareas:

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. En la pantalla de configuración, seleccione restaurar en la lista desplegable Comando .
4. En el campo Ruta de acceso a proyectos o soluciones , escriba la ruta de acceso a los archivos *.csproj . Puede usar el carácter comodín **/*.csproj para todos los archivos *.csproj en todas las subcarpetas.
5. Para que las fuentes se agreguen, asegúrese de que las fuentes que seleccione aquí y Use packages from NuGet.org are selected (Usar paquetes de NuGet.org ).
6. Seleccione Agregar.
7. Seleccione Validar y guardar y, a continuación, seleccione Guardar para confirmar el cambio.

Clásico

Puede agregar una tarea de restauración mediante el editor clásico.

1. En la pestaña Tareas de la canalización, seleccione Trabajo del agente 1 u otro trabajo que ejecute 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, seleccione .NET Core y, a continuación, seleccione Agregar.
4. En el panel izquierdo, seleccione la tarea de compilación dotnet agregada para abrir el editor de tareas.
5. Seleccione restaurar en la lista desplegable Comando . El nombre para mostrar cambia a dotnet restore.
6. En el campo Ruta de acceso a proyectos o soluciones , escriba la ruta de acceso a los archivos *.csproj . Puede usar el carácter comodín **/*.csproj para todos los archivos *.csproj en todas las subcarpetas.
7. Para que las fuentes se agreguen, asegúrese de que las fuentes que seleccione aquí y Use packages from NuGet.org are selected (Usar paquetes de NuGet.org ).
8. En el panel izquierdo, arrastre la tarea para colocarla antes de la tarea Compilar .
9. En la parte superior de la página, seleccione Guardar y poner en cola>Guardar.

Restauración de paquetes desde una fuente externa

Para especificar un repositorio nuGet externo, coloque la dirección URL en un archivo NuGet.config en el repositorio. Asegúrese de que se especifica cualquier fuente personalizada en el archivo deNuGet.config y de que las credenciales se especifican en una conexión de servicio NuGet.

Para restaurar paquetes desde una fuente externa, agregue la restore tarea como se indica en la sección anterior, pero cambie las opciones de configuración de la siguiente manera:

YAML

Agregue la tarea .NET Core (DotNetCoreCLI@2) directamente insertando el siguiente fragmento de código en el archivo azure-pipelines.yml antes de las tareas de compilación. Reemplace por <NuGet service connection> el nombre de la conexión de servicio.

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

Para usar el asistente de tareas:

1. Agregue la tarea .NET Core y seleccione restaurar en la pantalla de configuración como en el procedimiento anterior.
2. En Feeds to add (Fuentes que se van a agregar), seleccione Feeds (Fuentes) en mi NuGet.config.
3. En Ruta de acceso a NuGet.config, escriba la ruta de acceso al archivo NuGet.config , en relación con la raíz del repositorio. Puede seleccionar los puntos suspensivos ... junto al campo para ir a y seleccionar la ubicación.
4. En Credenciales para fuentes fuera de esta organización o colección, seleccione las credenciales que se usarán para los registros externos en el archivo deNuGet.config seleccionado. En el caso de las fuentes de la misma organización, puede dejar este campo en blanco. Las credenciales de la compilación se usan automáticamente.

Clásico

1. Agregue la tarea .NET Core y seleccione Restaurar en la pantalla de configuración.

2. En Feeds to add (Fuentes que se van a agregar), seleccione Feeds (Fuentes) en mi NuGet.config.

3. En Ruta de acceso a NuGet.config, escriba la ruta de acceso al archivo NuGet.config , en relación con la raíz del repositorio. Puede seleccionar los puntos suspensivos ... para ir a y seleccionar la ubicación del repositorio.

4. En Credenciales para fuentes fuera de esta organización o recopilación, seleccione las credenciales que se usarán para los registros externos ubicados en el NuGet.configseleccionado. En el caso de las fuentes de esta organización, puede dejar este campo en blanco porque las credenciales de la compilación se usan automáticamente.

   Puede seleccionar Administrar para ir a la configuración del proyecto y seleccionar la conexión. También puede seleccionar Nuevo para crear una conexión de servicio. Asegúrese de activar la casilla conceder permiso de acceso a todas las canalizaciones.

Restauración de paquetes para proyectos de .NET Framework

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 NuGetCommand@2 para restaurar esas dependencias.

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

Nota:

Para Ubuntu 24.04 o posterior, debe usar la tarea NuGetAuthenticate en lugar de la tarea NuGetCommand@2 con la CLI de .NET. Para obtener más información, consulte Compatibilidad con imágenes hospedadas en Ubuntu más recientes.

Compilación del proyecto

Compile el proyecto de .NET Core mediante la ejecución del dotnet build comando . Puede agregar el comando a la canalización mediante la tarea .NET Core (DotNetCoreCLI@2) o como un script de línea de comandos.

Uso de la tarea .NET Core

YAML

Puede agregar una tarea de compilación con el editor de canalizaciones de YAML editando directamente el archivo o mediante el asistente de tareas.

Agregue la tarea .NET Core (DotNetCoreCLI@2) directamente insertando el siguiente fragmento de código. Actualice para arguments que coincida con sus necesidades.

steps:
- task: DotNetCoreCLI@2
  displayName: Build
  inputs:
    command: build
    projects: '**/*.csproj'
    arguments: '--configuration $(buildConfiguration)'

Para usar el asistente de tareas:

1. Vaya a la posición en el archivo YAML donde desea insertar la tarea.
2. Seleccione la tarea .NET Core (DotNetCoreCLI@2).
3. Seleccione Compilar en la lista desplegable Comando .
4. En el campo Ruta de acceso a proyectos o soluciones , escriba la ruta de acceso a los archivos *.csproj . Puede usar el carácter comodín **/*.csproj para todos los archivos *.csproj en todas las subcarpetas.
5. Seleccione Agregar.
6. Seleccione Guardar para confirmar el cambio.

Clásico

Puede agregar una tarea de compilación mediante el editor clásico.

1. En la pestaña Tareas de la canalización, seleccione Trabajo del agente 1 u otro trabajo que ejecute 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, seleccione .NET Core y, a continuación, seleccione Agregar.
4. En el panel izquierdo, seleccione la tarea de compilación dotnet agregada para abrir el editor de tareas. El campo Comando ya muestra la compilación.
5. En el campo Ruta de acceso a proyectos o soluciones , escriba la ruta de acceso a los archivos *.csproj . Puede usar el carácter comodín **/*.csproj para todos los archivos *.csproj en todas las subcarpetas.
6. Para que las fuentes se agreguen, asegúrese de que las fuentes que seleccione aquí y Use packages from NuGet.org are selected (Usar paquetes de NuGet.org ).
7. En el panel izquierdo, arrastre la tarea para colocarla en la secuencia de tareas correcta.
8. En la parte superior de la página, seleccione Guardar y poner en cola>Guardar.

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

También puede compilar mediante un script de línea de comandos.

YAML

Para agregar una línea de comandos de compilación editando directamente el archivo YAML, agregue el código siguiente:

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

También puede usar el asistente de tareas para agregar la tarea Línea de comandos .

1. Vaya a la posición en el archivo YAML donde desea insertar la tarea.
2. Seleccione la tarea Línea de comandos (CmdLine@2) de la lista.
3. En el campo Script , escriba el dotnet build comando con parámetros. Por ejemplo, dotnet build --configuration $(buildConfiguration).
4. En Directoriode trabajo>, escriba la ruta de acceso al archivo *.csproj como directorio de trabajo. Si lo deja en blanco, el directorio de trabajo tiene $(Build.SourcesDirectory)como valor predeterminado .
5. Seleccione Agregar.
6. Seleccione Guardar para confirmar el cambio.

Clásico

Para agregar una línea de comandos de compilación mediante el editor clásico:

1. En la pestaña Tareas de la canalización, seleccione Trabajo del agente 1 u otro trabajo que ejecute 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, seleccione Línea de comandos y, a continuación, seleccione Agregar.
4. En el panel izquierdo, seleccione la tarea Script de línea de comandos agregada para abrir el editor de tareas.
5. Edite el nombre para mostrar si lo desea.
6. En Script, escriba el dotnet build comando con parámetros. Por ejemplo, dotnet build --configuration $(buildConfiguration).
7. En Directoriode trabajo>, escriba la ruta de acceso al archivo *.csproj como directorio de trabajo. Puede seleccionar los puntos suspensivos ... para ir a y seleccionar la ubicación del repositorio.
8. En el panel izquierdo, arrastre la tarea para colocarla en la secuencia de tareas correcta.
9. En la parte superior de la página, seleccione Guardar y poner en cola>Guardar.

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

Puede agregar otros comandos del SDK de .NET a la canalización mediante la tarea .NET Core (DotNetCoreCLI@2) o como scripts.

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

La tarea .NET Core (DotNetCoreCLI@2) le permite agregar fácilmente comandos de la CLI de .NET a la canalización. Puede agregar tareas de .NET Core (DotNetCoreCLI@2) editando el archivo YAML o mediante el editor clásico.

YAML

Para agregar un comando de .NET Core mediante el asistente de tareas en 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 desea ejecutar en la lista desplegable del campo Comando .
4. Configure las opciones necesarias.
5. Seleccione Agregar.
6. Seleccione Guardar para confirmar el cambio.

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

Puede agregar un comando de la CLI de .NET Core como en script el archivo azure-pipelines.yml . Por ejemplo:

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

Clásico

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

1. En la pestaña Tareas de la canalización, seleccione Trabajo del agente 1 u otro trabajo que ejecute 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, seleccione .NET Core y, a continuación, seleccione Agregar.
4. En el panel izquierdo, seleccione la tarea de compilación dotnet agregada para abrir el editor de tareas.
5. Edite el nombre para mostrar según sea necesario. El nombre de la tarea en el panel izquierdo se actualiza según corresponda.
6. En Comando, seleccione el comando que desea ejecutar, como personalizado.
7. Configure las opciones necesarias.
8. En el panel izquierdo, arrastre la tarea para colocarla en la secuencia de tareas correcta.
9. En la parte superior de la página, seleccione Guardar y poner en cola>Guardar.

Instalación de una herramienta

Para instalar una herramienta global de .NET Core como dotnetsay en una compilación que se ejecuta en Windows, agregue una tarea de .NET Core y establezca las siguientes propiedades en la configuración:

• Comando: personalizado
• Ruta de acceso a los proyectos: deje vacío
• Comando personalizado: tool
• Argumentos: install -g dotnetsay

Para ejecutar la herramienta, agregue una tarea Línea de comandos y escriba dotnetsay en el campo Script .

Ejecutar las pruebas

Cuando tenga proyectos de prueba en el repositorio, puede usar la tarea de .NET Core (DotNetCoreCLI@2) 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 la prueba se publican automáticamente en el servicio y están disponibles en el resumen de compilación. Puede usar los resultados de las pruebas para solucionar problemas de pruebas con errores y analizar el tiempo de las pruebas.

Para agregar una tarea de prueba a la canalización, agregue el siguiente fragmento de código al archivo azure-pipelines.yml :

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

Si usa el asistente de tareas para agregar la tarea .NET Core (DotNetCoreCLI@2), establezca las siguientes propiedades:

• Comando: test
• Ruta de acceso a los proyectos: establézcalo en los proyectos de prueba de la solución.
• Argumentos: --configuration $(BuildConfiguration)

Como alternativa, puede ejecutar el dotnet test comando con un registrador específico y, a continuación, usar la PublishTestResults@2 tarea :

steps:
# ...
# do this after your tests 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, puede recopilar métricas de cobertura de código 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 (DotNetCoreCLI@2) para ejecutar pruebas, los datos de cobertura se publican automáticamente en el servidor. Puede descargar el archivo *.coverage desde el resumen de compilación para verlo en Visual Studio.

Para recopilar cobertura de código, agregue el --collect "Code Coverage" argumento al agregar la tarea de prueba a la canalización.

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

Si usa el asistente de tareas para agregar la tarea .NET Core (DotNetCoreCLI@2), establezca las siguientes propiedades:

• Comando: test
• Ruta de acceso a los proyectos: establézcalo en los proyectos de prueba de la solución.
• Argumentos: --configuration $(BuildConfiguration) --collect "Code Coverage"

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

Como alternativa, para recopilar los resultados de cobertura de código mediante el dotnet test comando con un registrador específico y, a continuación, ejecute la tarea PublishTestResults@2 , use el código siguiente:

steps:
# ...
# do this after your tests 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 se basa 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 cobertura de código en el servidor con la tarea Publicar resultados de cobertura de código (PublishCodeCoverageResults@2). Debe configurar la herramienta de cobertura para generar resultados en formato de cobertura o JaCoCo.

Para ejecutar pruebas y publicar cobertura de código con Coverlet:

1. Agregue una referencia al paquete NuGet coverlet.collector.
2. Agregue el siguiente fragmento de código al archivo azure-pipelines.yml :

- 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: '<test project directory>'
  
- task: PublishCodeCoverageResults@2
  displayName: 'Publish code coverage report'
  inputs:
    codeCoverageTool: 'Cobertura'
    summaryFileLocation: '$(Agent.TempDirectory)/**/coverage.cobertura.xml'

Empaquetado y entrega del código

Para empaquetar y entregar la salida de compilación, puede hacer lo siguiente:

• Publique los artefactos de compilación en Azure Pipelines.
• Cree un paquete NuGet y publíquelo en la fuente de NuGet.
• Publique el paquete NuGet en Azure Artifacts.
• Cree un archivo ZIP para implementar en una aplicación web.
• Publique símbolos en un servidor de símbolos de Azure Artifacts o en un recurso compartido de archivos.

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

Publicación de artefactos en Azure Pipelines

Para publicar la salida de la compilación de .NET en la canalización, siga estos pasos.

1. Ejecute dotnet publish --output $(Build.ArtifactStagingDirectory) con la CLI de .NET o agregue la tarea de .NET Core (DotNetCoreCLI@2) con el comando publish .
2. Publique el artefacto mediante la tarea Publicar artefacto de canalización (PublishPipelineArtifact@1). Esta tarea carga todos los archivos de $(Build.ArtifactStagingDirectory) como un artefacto de la compilación.

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

steps:

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

- task: PublishPipelineArtifact@1
  inputs:
    targetPath: '$(Build.ArtifactStagingDirectory)' 
    artifactName: 'myWebsite'

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

Nota:

La publishWebProjects entrada de la tarea .NET Core (DotNetCoreCLI@2) se establece true en de forma predeterminada y publica todos los proyectos web del repositorio. Para más información, consulte el repositorio de GitHub azure-pipelines-tasks .

Para obtener más información, consulte Publicación y descarga de artefactos de compilación.

Publicación en una fuente de NuGet

Para crear un paquete NuGet y publicarlo en la fuente de NuGet, agregue el siguiente fragmento de código al archivo azure-pipelines.yml :

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

Nota:

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

Para más información sobre el control de versiones y la publicación de paquetes NuGet, consulte Publicación de paquetes NuGet con Azure Pipelines.

Publicación de un paquete NuGet en Azure Artifacts

Puede publicar los paquetes NuGet en la fuente de Azure Artifacts mediante la tarea NuGetCommand@2 . Para más información, consulte Publicación de paquetes NuGet con Azure Pipelines.

Publicación de un archivo ZIP en una aplicación web

Para crear un archivo ZIP listo para publicar en una aplicación web, agregue el siguiente fragmento de código a azure-pipelines.yml. Ejecute esta tarea después de compilar la aplicación, cerca del final de la canalización en la mayoría de los casos. Por ejemplo, ejecute esta tarea antes de implementar en una aplicación web de Azure en Windows.

steps:
# ...
- 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.

Publicación de símbolos

Puede usar la PublishSymbols@2 tarea para publicar símbolos en un servidor de símbolos de Azure Artifacts o en un recurso compartido de archivos. Para más información, consulte Publicación de símbolos.

Por ejemplo, para publicar símbolos en un recurso compartido de archivos, agregue 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>'

Para usar el editor clásico, agregue la tarea Orígenes de índice y publique símbolos en la canalización.

Solución de problemas

Si el proyecto se compila correctamente en la máquina local, pero no en Azure Pipelines, explore las siguientes causas potenciales y acciones correctivas.

• Las versiones preliminares del SDK de .NET Core no están instaladas en agentes hospedados por Microsoft y la implementación de una nueva versión del SDK en todos los centros de datos de Azure Pipelines puede tardar unas semanas. En lugar de esperar a que se complete un 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.

• Una nueva versión del SDK de .NET Core o Visual Studio podría interrumpir la compilación, por ejemplo, si contiene una versión o característica más reciente de la herramienta NuGet. Asegúrese de que las versiones y el entorno de ejecución del SDK de .NET Core en la máquina de desarrollo coincidan con el agente de canalización.

  Puede incluir un dotnet --version script 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 bien actualice los proyectos y la máquina de desarrollo a la versión de canalización del SDK de .NET Core.

• Es posible que las compilaciones produzcan errores intermitentes debido a problemas de conexión al restaurar paquetes desde NuGet.org. NuGet.org podría haber problemas o podría haber problemas de red entre el centro de datos de Azure y NuGet.org. Puede explorar si el uso de Azure Artifacts con orígenes ascendentes para almacenar en caché los paquetes mejora la confiabilidad de las compilaciones.

  Las credenciales de la canalización se usan automáticamente para conectarse 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.

• Es posible que esté usando alguna lógica en Visual Studio que no esté codificada en la canalización. Azure Pipelines ejecuta cada comando de una tarea secuencialmente en un nuevo proceso. Examine los registros de la compilación de canalizaciones para ver los comandos exactos que se ejecutaron en la compilación. Para localizar el problema, repita los mismos comandos en el mismo orden en la máquina de desarrollo.

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

Contenido relacionado

• Azure Artifacts
• Tareas de compilación y versión
• Herramientas de la CLI de .NET Core
• Pruebas unitarias en proyectos de .NET Core