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


Cargar el código

Upload el código a la nueva aplicación web GitHub o Azure Repos:

Inicio de sesión en Azure Pipelines

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.

En la organización seleccionada, cree un proyecto. Si no tiene ningún proyecto en la organización, aparecerá la pantalla Cree un proyecto para empezar. De lo contrario, seleccione el botón Crear proyecto en la esquina superior derecha del panel.

Creación de la canalización

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

  2. Vaya a Pipelinesy, a continuación, seleccione Nueva canalización.

  3. Siga los pasos del asistente seleccionando 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 instalación.

Cuando aparezca la pestaña Configurar, seleccione ASP.NET Core.

  1. Examine la nueva canalización para ver lo que hace yaml. Cuando esté listo, seleccione Guardar y ejecute.

    Save and run button in a new YAML pipeline

  2. Confirme un nuevo archivo azure-pipelines.yml en el repositorio. Una vez satisfecho con el mensaje, seleccione Guardar y ejecutar de nuevo.

    Si desea ver la canalización en acción, seleccione el trabajo de compilación.

    Dado que el código parece ser una buena coincidencia para la plantilla ASP.NET Core, creamos automáticamente la canalización.

    Ahora tiene una canalización YAML en funcionamiento ( ) en el repositorio que está lista azure-pipelines.yml para personalizar.

  3. Cuando esté listo para realizar cambios en la canalización, selecciónelo en la Pipelines y, a continuación, edite el archivo.

Obtenga más información para conocer algunas de las formas más comunes de personalizar la canalización.

YAML

  1. Agregue un azure-pipelines.yml archivo en el repositorio. Personalice el siguiente fragmento de código para la compilación.
trigger:
- master

pool: Default

variables:
  buildConfiguration: 'Release'

# do this before all your .NET Core tasks
steps:
- task: DotNetCoreInstaller@2
  inputs:
    version: '2.2.402' # replace this value with the version that you need for your project
- script: dotnet build --configuration $(buildConfiguration)
  displayName: 'dotnet build $(buildConfiguration)'
  1. Cree una canalización y seleccione la plantilla YAML.

  2. Establezca el grupo de agentes y la ruta de acceso del archivo YAML para la canalización.

  3. Guarde la canalización y poner en cola una compilación. Cuando aparezca el mensaje Build #nnnnnnnn.n has been queued (Compilar #nnnnnnnn.n se ha puesto en cola), seleccione el vínculo de número para ver la canalización en acción.

  4. Cuando esté listo para realizar cambios en la canalización, edite.

Obtenga más información para conocer algunas de las formas más comunes de personalizar la canalización.

Clásico

  1. Cree una canalización y seleccione la plantilla Canalización vacía.

  2. En el catálogo de tareas, busque y agregue la tarea .NET Core. La siguiente tarea se dotnet build ejecuta para compilar el código en el repositorio de ejemplo.

  3. Guarde la canalización y poner en cola una compilación. Cuando aparezca el mensaje Build #nnnnnnnn.n has been queued (Compilar #nnnnnnnn.n se ha puesto en cola), seleccione el vínculo de número para ver la canalización en acción.

    Ahora tiene una canalización de trabajo que está lista para personalizar.

  4. Cuando esté listo para realizar cambios en la canalización, edite.

Obtenga más información para conocer algunas de las formas más comunes de personalizar la canalización.

Entorno de compilación

Use Azure Pipelines para compilar los proyectos de .NET Core. Compile los proyectos en Windows, Linux o macOS sin necesidad de configurar la infraestructura. Los agentes hospedados por Microsoft en Azure Pipelines incluyen varias versiones preinstaladas de los SDK de .NET Core.

Ubuntu 18.04 se establece aquí en el archivo YAML.

pool:
  vmImage: 'ubuntu-18.04' # examples of other options: 'macOS-10.15', 'windows-2019'

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

Los agentes hospedados por Microsoft no incluyen algunas de las versiones anteriores del SDK de .NET Core. Tampoco suelen incluir versiones preliminares. Si necesita estos tipos de SDK en agentes hospedados por Microsoft, agregue la UseDotNet@2 al archivo YAML.

Para instalar la versión preliminar del SDK 5.0.x para compilar y 3.0.x para ejecutar pruebas destinadas a NET Core 3.0.x, agregue el siguiente fragmento de código:

steps:
- task: UseDotNet@2
  inputs:
    version: '5.0.x'
    includePreviewVersions: true # Required for preview versions

- task: UseDotNet@2
  inputs:
    version: '3.0.x'
    packageType: runtime

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

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

Sugerencia

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

Puede compilar los proyectos de .NET Core mediante el entorno SDK de .NET Core y runtime en Windows, Linux o macOS. Las compilaciones se ejecutan en un agente auto hospedado. Asegúrese de que tiene instalada la versión necesaria de la SDK de .NET Core tiempo de ejecución en el agente.

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 a través de la tarea .NET Core o directamente en un script de la dotnet restore canalización. dotnet restore

Puede descargar paquetes NuGet desde Azure Artifacts, NuGet.org o cualquier otro repositorio de NuGet externo. La tarea .NET Core es especialmente útil para restaurar paquetes desde fuentes NuGet autenticadas.

Esta canalización usa una fuente de artefactos para dotnet restore en CLI de .NET Core dotnet restore.

trigger:
- master

pool:
  vmImage: 'windows-latest'

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

Puede descargar paquetes NuGet desde NuGet.org.

dotnet restore usa internamente una NuGet.exe versión de que se empaqueta con el SDK de .NET Core. dotnet restore solo puede restaurar los paquetes especificados en los archivos de proyecto de .NET .csproj Core. Si también tiene un proyecto de Microsoft .NET Framework en la solución o usa para especificar las dependencias, use la tarea NuGet para package.json restaurar esas package.json dependencias.

En SDK de .NET Core versión 2.0 y posteriores, los paquetes se restauran automáticamente al ejecutar otros comandos, como dotnet build .

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

A veces, las compilaciones pueden producir errores debido a problemas de conexión al restaurar paquetes desde NuGet.org. Puede usar Azure Artifacts orígenes ascendentes y almacenar en caché los paquetes. Las credenciales de la canalización se usan automáticamente cuando se conecta a Azure Artifacts. Estas credenciales normalmente se derivan de la cuenta Project servicio de compilación de recopilación.

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

Si usa agentes hospedados por Microsoft, obtiene una nueva máquina cada vez que ejecuta una compilación, lo que significa restaurar los paquetes cada vez. La restauración puede tardar mucho tiempo. Para mitigarlo, puede usar Azure Artifacts o un agente auto hospedado con la ventaja de usar la caché de paquetes.

Para restaurar paquetes desde una fuente personalizada externa, use la siguiente 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>
# ...

Para obtener más información sobre NuGet conexiones de servicio, vea Publicar en NuGet fuente.

  1. Seleccione Tareas en la canalización. Seleccione el trabajo que ejecuta las tareas de compilación. A continuación, + seleccione esta opción para agregar una nueva tarea a ese trabajo.

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

  3. Seleccione la tarea y, en Comando, seleccione restaurar.

  4. Especifique cualquier otra opción que necesite para esta tarea. A continuación, guarde la compilación.

Nota:

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

Compilación del proyecto

Para compilar el proyecto de .NET Core, ejecute el comando en la canalización dotnet build o use la tarea .NET Core.

Para compilar el proyecto mediante la tarea .NET Core, agregue el siguiente fragmento de código al azure-pipelines.yml archivo:

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

Puede ejecutar cualquier comando dotnet personalizado en la canalización. En el ejemplo siguiente se muestra cómo instalar y usar una herramienta global de .NET, dotnetsay:

steps:
- task: DotNetCoreCLI@2
  displayName: 'Install dotnetsay'
  inputs:
    command: custom
    custom: tool
    arguments: 'install -g dotnetsay'

Build

  1. Seleccione Tareas en la canalización. Seleccione el trabajo que ejecuta las tareas de compilación. A + continuación, seleccione esta opción para agregar una nueva tarea a ese trabajo.

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

  3. Seleccione la tarea y, en Comando, seleccione compilar o publicar.

  4. Especifique cualquier otra opción que necesite para esta tarea y guarde la compilación.

Instalación de una herramienta

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

  1. Agregue la tarea .NET Core y establezca las siguientes propiedades:

    • Comando: personalizado.
      • Ruta de acceso a los proyectos:deje vacío.
    • Comando personalizado:herramienta.
    • Argumentos: .
  2. Agregue una tarea línea de comandos y establezca las siguientes propiedades:

    • Script: .

Ejecutar las pruebas

Si tiene proyectos de prueba en el repositorio, use la tarea .NET Core para ejecutar pruebas unitarias mediante marcos de pruebas como MSTest, xUnit y NUnit. El proyecto de prueba debe hacer referencia a Microsoft .NET.Test.SDK versión 15.8.0 o posterior. 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 problemas de pruebas con errores y análisis de tiempo de prueba.

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

Una alternativa consiste en ejecutar el comando con un registrador específico y, dotnet test a continuación, usar la dotnet test datos:

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'

Use la tarea .NET Core con el conjunto de comandos para probar. La ruta de acceso a los proyectos debe hacer referencia a los proyectos de prueba de la solución.

Recopilación de cobertura de código

Si va a crear 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 Microsoft .NET.Test.SDK versión 15.8.0 o posterior. Si usa la tarea .NET Core para ejecutar pruebas, los datos de cobertura se publican automáticamente en el servidor. El archivo .coverage se puede descargar desde el resumen de compilación para verlo en Visual Studio.

Agregue 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) --collect "Code coverage"'

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

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'
  1. Agregue la tarea .NET Core al trabajo de compilación y establezca las siguientes propiedades:

    • Comando: test.
    • Ruta de acceso alos proyectos: debe hacer referencia a los proyectos de prueba de la solución.
    • Argumentos: .
  2. Asegúrese de que la opción Publicar resultados de pruebas permanece seleccionada.

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 cobertura de código en el servidor con la tarea Publicar resultados de cobertura de código. La herramienta de cobertura debe configurarse para generar resultados en formato cobertura o cobertura de JaCoCo.

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

  • Agregue una referencia al paquete NuGet en los proyectos de prueba para proyectos de .NET inferiores a coverlet.msbuild .NET 5. Para .NET 5, agregue una referencia al coverlet.collector NuGet paquete.
  • Agregue el siguiente fragmento de código al azure-pipelines.yml archivo:
- task: UseDotNet@2
  inputs:
    version: '5.0.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

Upload la salida de compilación que se Azure Pipelines. Puede crear y publicar un paquete de NuGet o empaquetar la salida de compilación en un archivo .zip para implementarlo en una aplicación web.

Publicar artefactos en Azure Pipelines

Para publicar la salida de la compilaciónde .NET, realice las siguientes tareas:

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

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

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: 'myWebsiteName'

Nota:

La dotNetCoreCLI@2 tarea tiene una entrada que se establece en true publishWebProjectsdotNetCoreCLI@2 forma predeterminada. Esta tarea publica todos los proyectos web en el 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 la publicación, use la Utilidad: copiar archivos.

Publicar en una fuente NuGet de datos

Para crear y publicar un paquete 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@0
  input:
    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 NuGet paquetes,vea Publicar en NuGet fuente .

Implementación de una aplicación sitio

Para crear un .zip de archivos 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 .

Publicar artefactos en Azure Pipelines

Use la tarea Publicar Artifacts para publicar la salida de la compilación en Azure Pipelines.

Publicar en una fuente NuGet de datos

Si desea publicar el código en una fuente de NuGet, siga estos pasos:

  1. Use una tarea de .NET Core con el comando establecido en pack.

  2. Publique el paquete en una NuGet de distribución.

Implementación de una aplicación sitio

  1. Use una tarea de .NET Core con el conjunto de comandos para publicar.

  2. Asegúrese de que ha seleccionado la opción para crear un archivo .zip archivo.

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

Compilación de una imagen e inserción en el registro de contenedor

Para la aplicación, también puede compilar una imagen einsertarla en un registro de contenedor.

Solución de problemas

Si puede compilar el proyecto en la máquina de desarrollo, pero tiene problemas para compilarlo en Azure Pipelines, explore las siguientes posibles causas y acciones correctivas:

  • No instalamos versiones preliminares de los SDK de .NET Core en agentes hospedados por Microsoft. Una vez publicada una nueva versión del SDK de .NET Core, puede tardar unas semanas en lanzarse en todos los centros de Azure Pipelines datos. No tiene que esperar a que se complete este lanzamiento. Puede usar el Instalador de herramientas de .NET Core para instalar la versión que desee de la SDK de .NET Core en agentes hospedados por Microsoft.
  • Compruebe las SDK de .NET Core y el entorno de ejecución en la máquina de desarrollo y asegúrese de que coinciden con el agente. Puede incluir un script de línea de comandos dotnet --version 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 Visual Studio IDE que no está codificado en la canalización. Azure Pipelines ejecuta cada uno de los comandos especificados en las tareas una tras otra en un nuevo proceso. 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 mixta que incluye algunos proyectos de .NET Core y algunos proyectos de .NET Framework, también debe usar la tarea NuGet para restaurar los paquetes especificados en los archivos. Agregue la MSBuild o Visual Studio compilar para compilar los .NET Framework proyecto.

  • Es posible que las compilaciones generen errores de forma intermitente al restaurar paquetes. Dither NuGet.org tiene problemas o hay problemas de red entre el centro de datos de Azure y NuGet.org. Es posible que quiera explorar si el uso de Azure Artifacts con NuGet.org como origen ascendente mejora la confiabilidad de las compilaciones, ya que no está bajo nuestro control.

  • En ocasiones, cuando se lanza una nueva versión de la SDK de .NET Core o Visual Studio, la compilación podría interrumpirse. Por ejemplo, si una versión o característica más reciente de NuGet herramienta se incluye con el SDK. Para aislar este problema, use 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 más información sobre Azure Artifacts y el servicio de Administración de paquetes TFS?

A: Administración de paquetes en Azure Artifacts

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

A: CLI de .NET Core herramientas

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

A: Pruebas unitarias en proyectos de .NET Core

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

A: Tareas de compilación y versión

Azure Pipelines | Azure DevOps Server 2020 | Azure DevOps Server 2019 | TFS 2018 | TFS 2017

Use una canalización para compilar y probar automáticamente los proyectos de .NET Core. Obtenga información sobre cómo realizar las siguientes tareas:

Nota:

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

Nota:

En Microsoft Team Foundation Server (TFS) 2018 y versiones anteriores, las canalizaciones de compilación y versión se denominan definiciones, las ejecuciones se denominan compilaciones, las conexiones de servicio se denominan puntos de conexión de servicio, las fases se denominan entornos y los trabajos se denominan fases.

Nota:

Las instrucciones siguientes se aplican a la versión 2017.3 y posteriores de TFS.

Cree su primera canalización

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

Creación de un proyecto de .NET

Si no tiene un proyecto de .NET con el que trabajar, cree uno nuevo y cargue el código en el repositorio de GitHub o Azure Repos. Empiece por instalar el SDK de .NET 6.0 más reciente.

Cree una nueva aplicación web de .NET 6.

dotnet new webapp -f net6.0

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

dotnet run