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:

Requisitos previos

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

Configure su entorno de compilación

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

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.

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

pool:
  name: myPrivateAgents
  demands:
  - agent.os -equals Darwin
  - anotherCapability -equals somethingElse

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

pool:
  vmImage: 'ubuntu-latest' 

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

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

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.

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.

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

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

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

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

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

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'

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: PublishBuildArtifacts@1
  inputs:
    PathtoPublish: '$(Build.ArtifactStagingDirectory)'
    ArtifactName: 'drop'

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

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:

• 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