Crie, teste e implante projetos .NET Core

Serviços de DevOps do Azure | Azure DevOps Server | Azure DevOps Server 2022 | Azure DevOps Server 2020

Este artigo descreve como usar o Azure Pipelines para trabalhar com projetos .NET Core. O artigo orienta você pelas seguintes tarefas:

• Crie um aplicativo Web .NET Core e carregue-o em um repositório GitHub.
• Crie um projeto do Azure DevOps e um pipeline do Azure Pipelines para criar o projeto.
• Configure seu ambiente de compilação com agentes hospedados ou auto-hospedados pela Microsoft.
• Restaure dependências, crie seu projeto e teste com a tarefa .NET Core (DotNetCoreCLI@2) ou um script.
• Use a tarefa .NET Core (DotNetCoreCLI@2) para adicionar outros comandos do .NET SDK ao seu pipeline.
• Use a tarefa Publicar resultados de cobertura de código (Publish code coverage results v2) para publicar resultados de cobertura de código.
• Empacote e entregue sua saída de compilação para seu pipeline, um feed NuGet, um arquivo ZIP ou outros destinos.

Nota

Para trabalhar com projetos do .NET Framework, consulte Criar aplicativos ASP.NET com o .NET Framework.

Pré-requisitos

Para concluir todos os procedimentos neste artigo, você precisa dos seguintes pré-requisitos:

• Uma organização Azure DevOps. Você pode criar um gratuitamente.
• Associação ao grupo Administradores de Projeto da organização, para que você possa criar projetos de DevOps do Azure e conceder acesso de projeto a pipelines. Os proprietários da organização do Azure DevOps têm automaticamente essa associação.
• Um projeto de DevOps do Azure na organização. Crie um projeto no Azure DevOps.
• A capacidade de executar pipelines em agentes hospedados pela Microsoft, solicitando uma camada gratuita de trabalhos paralelos. Este pedido pode demorar vários dias úteis a processar. Para obter mais informações, consulte Configurar e pagar por trabalhos paralelos.
• A função Administrador ou Criador para conexões de serviço, que você pode atribuir como Administrador de Projeto.
• Uma conta e um repositório do GitHub .

Crie um projeto .NET e carregue-o no GitHub

Se você quiser usar um projeto .NET já em seu repositório GitHub, você pode ignorar esta seção.

Se você não tiver um projeto .NET para trabalhar, crie um novo em sua máquina local da seguinte maneira:

1. Instale o SDK do .NET 8.0 ou certifique-se de que está instalado.
2. Abra uma janela de terminal na sua máquina local.
3. Crie um diretório de projeto e navegue até ele.
4. Crie um novo aplicativo Web .NET 8 executando o dotnet new webapp -f net8.0.
5. Crie e execute o aplicativo localmente usando dotnet runo .
6. Quando o aplicativo for iniciado, pressione Ctrl+C para desligá-lo.
7. Carregue ou conecte o projeto local ao seu repositório GitHub.

Criar uma canalização

Se você tiver um pipeline que deseja usar, ignore esta seção. Caso contrário, você pode usar o editor de pipeline YAML ou o editor clássico para criar um pipeline da seguinte maneira:

YAML

1. Em seu projeto do Azure DevOps, selecione Pipelines no menu de navegação esquerdo.

2. Selecione Novo pipeline ou Criar pipeline se esse pipeline for o primeiro do projeto.

3. Na tela Onde está seu código , selecione GitHub.

4. Poderá ser redirecionado para o GitHub para iniciar sessão. Em caso afirmativo, insira suas credenciais do GitHub.

5. Na tela Selecione um repositório , selecione o repositório em que seu aplicativo .NET está.

6. Você pode ser redirecionado para o GitHub para instalar o aplicativo Azure Pipelines. Em caso afirmativo, selecione Aprovar e instalar.

7. Na guia Configurar , selecione Mostrar mais e, em seguida, selecione o modelo de pipeline ASP.NET Core na lista. Este modelo fornece muitas das etapas e configurações descritas neste artigo.

   Você também pode selecionar Pipeline inicial na guia Configurar para começar com um pipeline mínimo e adicionar as etapas e configurações você mesmo.

8. Na guia Revisão , examine o código YAML. Você pode personalizar o arquivo de acordo com suas necessidades. Por exemplo, você pode especificar um pool de agentes diferente ou adicionar uma tarefa para instalar um SDK .NET diferente.

9. Quando estiver pronto, selecione Salvar e executar.

   

10. Opcionalmente, edite a mensagem de confirmação e selecione Salvar e executar novamente.

11. Na guia Resumo , selecione o trabalho na seção Trabalhos para observar seu pipeline em ação.

Clássico

1. Em seu projeto do Azure DevOps, selecione Pipelines no menu de navegação esquerdo.

2. Selecione Novo pipeline ou Criar pipeline se esse pipeline for o primeiro do projeto.

3. Na tela Onde está seu código , selecione Usar o editor clássico para criar um pipeline sem YAML.

   Nota

   A capacidade de criar pipelines clássicos é desativada por padrão para novas organizações e projetos de DevOps do Azure. Se você não vir a opção de usar o editor clássico, desative as opções Desabilitar a criação de pipelines de compilação clássicos e Desabilitar a criação de pipelines de versão clássica em Configurações> da organização Configuraçõesde pipelines> e/ou Configurações de projeto>>

4. Em Selecione uma fonte, selecione GitHub.

5. Forneça um nome de conexão e selecione Autorizar usando OAuth. Você também pode optar por autorizar com o Aplicativo GitHub do Azure Pipelines ou um token de acesso pessoal (PAT) do GitHub.

6. Forneça o nome do repositório GitHub, incluindo organização ou usuário, e sua ramificação padrão, geralmente principal.

7. Selecione Continuar.

8. Na tela Selecionar um modelo , procure e selecione o modelo ASP.NET Core e, em seguida, selecione Aplicar. A página de pipeline é aberta, onde você pode adicionar tarefas, especificar pools de agentes e agentes e configurar outras opções de compilação.

   O modelo ASP.NET Core fornece muitas das etapas e configurações descritas neste artigo. Você também pode selecionar Trabalho vazio para começar com um pipeline mínimo e adicionar as tarefas e configurações por conta própria.

9. Na guia Tarefas , em Pool de agentes, selecione Pipelines do Azure para usar agentes hospedados pela Microsoft.

10. Em Especificação do agente, selecione windows-latest para este exemplo.

11. Selecione Salvar e enfileirar>Salvar e enfileirar na parte superior da página.

12. Na tela Executar pipeline , insira um comentário Salvar e selecione Salvar e executar.

13. Selecione o trabalho na seção Trabalhos na guia Resumo para ver seu pipeline em ação.

Você pode adicionar tarefas ao trabalho do Agente 1 selecionando + no trabalho e selecionando uma tarefa na lista. Por exemplo, você pode adicionar a tarefa Usar .NET Core como a primeira tarefa para instalar o SDK do .NET.

Agora você tem um pipeline de trabalho pronto para personalizar.

Configurar seu ambiente de compilação

Você pode criar seus projetos .NET Core usando o SDK do .NET Core e o tempo de execução para Windows, Linux ou macOS. Por padrão, suas compilações são executadas em agentes hospedados pela Microsoft, portanto, você não precisa configurar a infraestrutura.

Os agentes hospedados pela Microsoft do Azure Pipelines incluem várias versões pré-instaladas de SDKs do .NET Core com suporte. Consulte Agentes hospedados pela Microsoft para obter uma lista completa de imagens disponíveis e exemplos de configuração.

O seguinte trecho de pipeline YAML define o Ubuntu OS para o pool de agentes.

pool:
  vmImage: 'ubuntu-latest' 

Os agentes hospedados pela Microsoft não incluem algumas versões mais antigas do SDK do .NET Core e normalmente não incluem versões de pré-lançamento. Se você precisar dessas versões do SDK em agentes hospedados pela Microsoft, poderá instalá-las usando a tarefa Usar DotNet (UseDotNet@2).

Por exemplo, o código a seguir instala o SDK do .NET 5.0.x:

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

Os agentes do Windows já incluem um ambiente de execução .NET Core. Para instalar um SDK mais recente, defina performMultiLevelLookup como true no seguinte trecho:

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

Agentes autogeridos

Como alternativa, você pode usar agentes auto-hospedados para criar seus projetos .NET Core. Você pode configurar agentes auto-hospedados Linux, macOS ou Windows .

Os agentes auto-hospedados permitem:

• Evite o custo de execução do instalador da UseDotNet@2 ferramenta.
• Diminua o tempo de compilação se você tiver um repositório grande.
• Execute compilações incrementais.
• Use SDKs de visualização ou privados que a Microsoft não suporta oficialmente.
• Use SDKs disponíveis somente em seus ambientes corporativos ou locais.

Para obter mais informações, consulte Agentes autohospedados.

Restaurar dependências

Os pacotes NuGet são uma maneira de seu projeto depender de código que você não cria. Você pode baixar pacotes NuGet e ferramentas específicas do projeto executando o dotnet restore comando, seja por meio da tarefa .NET Core (DotNetCoreCLI@2) ou como um script em seu pipeline. O dotnet restore comando usa o NuGet.exe empacotado com o SDK do .NET Core e só pode restaurar pacotes especificados nos arquivos *.csproj do projeto .NET Core.

Você pode usar a tarefa .NET Core (DotNetCoreCLI@2) para baixar e restaurar pacotes NuGet do Azure Artifacts, NuGet.org ou outro repositório NuGet externo ou interno autenticado. Se o feed do NuGet estiver no mesmo projeto que seu pipeline, você não precisará autenticar. Para obter mais informações, consulte Tarefa .NET Core (DotNetCoreCLI@2).

Quando você usa agentes hospedados pela Microsoft, obtém uma nova máquina toda vez que executa uma compilação, que restaura os pacotes a cada execução. A restauração pode levar uma quantidade significativa de tempo. Para atenuar esse problema, use os Artefatos do Azure ou um agente auto-hospedado para aproveitar o cache do pacote.

O pipeline a seguir usa a DotNetCoreCLI@2 tarefa para restaurar um feed de Artefato do Azure.

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

No .NET Core SDK versão 2.0 e mais recente, os pacotes são restaurados automaticamente quando você executa comandos como dotnet build. Você ainda precisará usar a tarefa .NET Core (DotNetCoreCLI@2) para restaurar pacotes se usar um feed autenticado.

Gerencie as credenciais de um feed autenticado criando uma conexão de serviço NuGet em conexõesde serviço de >> projeto. Para obter mais informações sobre conexões de serviço NuGet, consulte Publicar pacotes NuGet com Pipelines do Azure.

Restaurar pacotes a partir de NuGet.org

Para restaurar pacotes do NuGet.org, atualize seu pipeline da seguinte maneira.

YAML

Você pode adicionar o comando restore ao seu pipeline editando o código YAML diretamente ou usando o assistente de tarefas.

Adicione a tarefa .NET Core (DotNetCoreCLI@2) diretamente inserindo o seguinte trecho em seu arquivo de azure-pipelines.yml antes das tarefas de compilação.

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

Para usar o assistente de tarefas:

1. Vá para a posição no arquivo YAML onde você deseja inserir a tarefa.
2. Selecione .NET Core no catálogo de tarefas.
3. Na tela de configuração, selecione restaurar na lista suspensa Comando .
4. No campo Caminho para projeto(s) ou solução(ões), insira o caminho para seus arquivos *.csproj . Você pode usar o curinga **/*.csproj para todos os arquivos *.csproj em todas as subpastas.
5. Para adicionar Feeds, certifique-se de que O(s) feed(s) que seleciono(s) aqui e Usar pacotes de NuGet.org estão selecionados.
6. Selecione Adicionar.
7. Selecione Validar e guardar e, em seguida, selecione Guardar para confirmar a alteração.

Clássico

Você pode adicionar uma tarefa de restauração usando o editor clássico.

1. Na guia Tarefas do pipeline, selecione Trabalho de agente 1 ou outro trabalho que execute suas tarefas de compilação.
2. Selecione + para adicionar uma nova tarefa a essa tarefa.
3. No catálogo de tarefas, selecione .NET Core e, em seguida, selecione Adicionar.
4. No painel esquerdo, selecione a tarefa de compilação dotnet adicionada para abrir o editor de tarefas.
5. Selecione restaurar na lista suspensa Comando . O nome para exibição muda para restauração dotnet.
6. No campo Caminho para projeto(s) ou solução(ões), insira o caminho para seus arquivos *.csproj . Você pode usar o curinga **/*.csproj para todos os arquivos *.csproj em todas as subpastas.
7. Para adicionar Feeds, certifique-se de que O(s) feed(s) que seleciono(s) aqui e Usar pacotes de NuGet.org estão selecionados.
8. No painel esquerdo, arraste a tarefa para posicioná-la antes da tarefa Construir .
9. Na parte superior da página, selecione Salvar fila & Salvar>.

Restaurar pacotes a partir de um feed externo

Para especificar um repositório NuGet externo, coloque a URL em um arquivo NuGet.config no repositório. Verifique se qualquer feed personalizado está especificado no arquivo NuGet.config e se as credenciais estão especificadas em uma conexão de serviço NuGet.

Para restaurar pacotes de um feed externo, adicione a restore tarefa conforme as instruções da seção anterior, mas altere as definições de configuração da seguinte maneira:

YAML

Adicione a tarefa .NET Core (DotNetCoreCLI@2) diretamente inserindo o seguinte trecho em seu arquivo de azure-pipelines.yml antes das tarefas de compilação. Substitua <NuGet service connection> pelo nome da conexão de serviço.

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 o assistente de tarefas:

1. Adicione a tarefa .NET Core e selecione restaurar na tela de configuração, como no procedimento anterior.
2. Para Feeds a adicionar, selecione Feeds no meu NuGet.config.
3. Em Caminho para NuGet.config, insira o caminho para o arquivo NuGet.config , relativo à raiz do repositório. Você pode selecionar as reticências ao lado do campo para navegar e selecionar o local.
4. Em Credenciais para feeds fora desta organização/coleção, selecione as credenciais a serem usadas para registros externos no arquivo deNuGet.config selecionado. Para feeds na mesma organização, você pode deixar esse campo em branco. As credenciais da compilação são usadas automaticamente.

Clássico

1. Adicione a tarefa .NET Core e selecione restaurar na tela de configuração.

2. Para Feeds a adicionar, selecione Feeds no meu NuGet.config.

3. Em Caminho para NuGet.config, insira o caminho para o arquivo NuGet.config , relativo à raiz do repositório. Você pode selecionar as reticências ... para navegar e selecionar o local do repositório.

4. Em Credenciais para feeds fora desta organização/coleção, selecione as credenciais a serem usadas para registros externos localizados no NuGet.configselecionado. Para feeds nesta organização, você pode deixar esse campo em branco porque as credenciais da compilação são usadas automaticamente.

   Você pode selecionar Gerenciar para ir para as configurações do seu projeto e selecionar a conexão. Você também pode selecionar Novo para criar uma conexão de serviço. Certifique-se de marcar a caixa de seleção Conceder permissão de acesso a todos os pipelines.

Restaurar pacotes para projetos do .NET Framework

Se você também tiver um projeto do Microsoft .NET Framework em sua solução ou usar package.json para especificar suas dependências, use a tarefa NuGetCommand@2 para restaurar essas dependências.

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

Nota

Para o Ubuntu 24.04 ou superior, você deve usar a tarefa NuGetAuthenticate em vez da tarefa NuGetCommand@2 com a CLI .NET. Para obter mais informações, consulte Suporte para imagens hospedadas mais recentes do Ubuntu.

Construa o seu projeto

Crie seu projeto .NET Core executando o dotnet build comando. Você pode adicionar o comando ao seu pipeline usando a tarefa .NET Core (DotNetCoreCLI@2) ou como um script de linha de comando.

Usar a tarefa .NET Core

YAML

Você pode adicionar uma tarefa de compilação com o editor de pipeline YAML editando diretamente o arquivo ou usando o assistente de tarefa.

Adicione a tarefa .NET Core (DotNetCoreCLI@2) diretamente inserindo o seguinte trecho. Atualize o arguments para corresponder às suas necessidades.

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

Para usar o assistente de tarefas:

1. Vá para a posição no arquivo YAML onde você deseja inserir a tarefa.
2. Selecione a tarefa .NET Core (DotNetCoreCLI@2).
3. Selecione build na lista suspensa Comando .
4. No campo Caminho para projeto(s) ou solução(ões), insira o caminho para seus arquivos *.csproj . Você pode usar o curinga **/*.csproj para todos os arquivos *.csproj em todas as subpastas.
5. Selecione Adicionar.
6. Selecione Salvar para confirmar a alteração.

Clássico

Você pode adicionar uma tarefa de compilação usando o editor clássico.

1. Na guia Tarefas do pipeline, selecione Trabalho de agente 1 ou outro trabalho que execute suas tarefas de compilação.
2. Selecione + para adicionar uma nova tarefa a essa tarefa.
3. No catálogo de tarefas, selecione .NET Core e, em seguida, selecione Adicionar.
4. No painel esquerdo, selecione a tarefa de compilação dotnet adicionada para abrir o editor de tarefas. O campo Comando já mostra build.
5. No campo Caminho para projeto(s) ou solução(ões), insira o caminho para seus arquivos *.csproj . Você pode usar o curinga **/*.csproj para todos os arquivos *.csproj em todas as subpastas.
6. Para adicionar Feeds, certifique-se de que O(s) feed(s) que seleciono(s) aqui e Usar pacotes de NuGet.org estão selecionados.
7. No painel esquerdo, arraste a tarefa para posicioná-la na sequência de tarefas correta.
8. Na parte superior da página, selecione Salvar fila & Salvar>.

Crie o .NET Core com um script de linha de comando

Você também pode criar usando um script de linha de comando.

YAML

Para adicionar uma linha de comando de compilação editando diretamente o arquivo YAML, adicione o seguinte código:

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

Você também pode usar o assistente de tarefas para adicionar a tarefa de linha de comando .

1. Vá para a posição no arquivo YAML onde você deseja inserir a tarefa.
2. Selecione a tarefa Linha de comando (CmdLine@2) na lista.
3. No campo Script , insira o dotnet build comando com parâmetros. Por exemplo, dotnet build --configuration $(buildConfiguration).
4. EmDiretório de Trabalho>, insira o caminho para o arquivo *.csproj como o diretório de trabalho. Se você deixá-lo em branco, o diretório de trabalho assume $(Build.SourcesDirectory)como padrão .
5. Selecione Adicionar.
6. Selecione Salvar para confirmar a alteração.

Clássico

Para adicionar uma linha de comando de compilação usando o editor clássico:

1. Na guia Tarefas do pipeline, selecione Trabalho de agente 1 ou outro trabalho que execute suas tarefas de compilação.
2. Selecione + para adicionar uma nova tarefa a essa tarefa.
3. No catálogo de tarefas, selecione Linha de comando e, em seguida, selecione Adicionar.
4. No painel esquerdo, selecione a tarefa Script de linha de comando adicionada para abrir o editor de tarefas.
5. Edite o Nome para exibição, se desejar.
6. Em Script, insira o dotnet build comando com parâmetros. Por exemplo, dotnet build --configuration $(buildConfiguration).
7. EmDiretório de Trabalho>, insira o caminho para o arquivo *.csproj como o diretório de trabalho. Você pode selecionar as reticências ... para navegar e selecionar o local do repositório.
8. No painel esquerdo, arraste a tarefa para posicioná-la na sequência de tarefas correta.
9. Na parte superior da página, selecione Salvar fila & Salvar>.

Adicionar outros comandos do SDK do .NET ao seu pipeline

Você pode adicionar outros comandos do SDK do .NET ao seu pipeline usando a tarefa .NET Core (DotNetCoreCLI@2) ou como scripts.

Adicionar um comando da CLI do .NET com a tarefa .NET Core

A tarefa .NET Core (DotNetCoreCLI@2) permite adicionar facilmente comandos da CLI do .NET ao seu pipeline. Você pode adicionar tarefas do .NET Core (DotNetCoreCLI@2) editando seu arquivo YAML ou usando o editor clássico.

YAML

Para adicionar um comando .NET Core usando o assistente de tarefas no editor de pipeline YAML, execute as seguintes etapas:

1. Vá para a posição no arquivo YAML onde você deseja inserir a tarefa.
2. Selecione .NET Core no catálogo de tarefas.
3. Selecione o comando que deseja executar na lista suspensa no campo Comando .
4. Configure as opções necessárias.
5. Selecione Adicionar.
6. Selecione Salvar para confirmar a alteração.

Adicionar um comando da CLI do .NET Core em um script

Você pode adicionar um comando da CLI do .NET Core como um script em seu arquivo azure-pipelines.yml . Por exemplo:

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

Clássico

Para adicionar um comando .NET Core usando o editor clássico, execute as seguintes etapas:

1. Na guia Tarefas do pipeline, selecione Trabalho de agente 1 ou outro trabalho que execute suas tarefas de compilação.
2. Selecione + para adicionar uma nova tarefa a essa tarefa.
3. No catálogo de tarefas, selecione .NET Core e, em seguida, selecione Adicionar.
4. No painel esquerdo, selecione a tarefa de compilação dotnet adicionada para abrir o editor de tarefas.
5. Edite o Nome para exibição conforme desejado. O nome da tarefa no painel esquerdo é atualizado de acordo.
6. Em Comando, selecione o comando que deseja executar, como personalizado.
7. Configure as opções necessárias.
8. No painel esquerdo, arraste a tarefa para posicioná-la na sequência de tarefas correta.
9. Na parte superior da página, selecione Salvar fila & Salvar>.

Instalar uma ferramenta

Para instalar uma ferramenta global do .NET Core como dotnetsay em uma compilação em execução no Windows, adicione uma tarefa .NET Core e defina as seguintes propriedades na configuração:

• Comando: personalizado
• Caminho para projetos: deixe em branco
• Comando personalizado: tool
• Argumentos: install -g dotnetsay

Para executar a ferramenta, adicione uma tarefa de Linha de Comando e insira dotnetsay no campo Script .

Execute os testes

Quando você tem projetos de teste em seu repositório, você pode usar a tarefa .NET Core (DotNetCoreCLI@2) para executar testes de unidade usando estruturas de teste como MSTest, xUnit e NUnit. O projeto de teste deve fazer referência a Microsoft.NET.Test.SDK versão 15.8.0 ou superior.

Os resultados do teste são publicados automaticamente no serviço e estão disponíveis para você no resumo da compilação. Você pode usar os resultados do teste para solucionar problemas de testes com falha e analisar o tempo do teste.

Para adicionar uma tarefa de teste ao pipeline, adicione o seguinte trecho ao arquivo azure-pipelines.yml :

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

Se você usar o assistente de tarefas para adicionar a tarefa .NET Core (DotNetCoreCLI@2), defina as seguintes propriedades:

• Comando: teste
• Caminho para projetos: defina para os projetos de teste em sua solução
• Argumentos: --configuration $(BuildConfiguration)

Como alternativa, você pode executar o dotnet test comando com um registrador específico e, em seguida, usar a PublishTestResults@2 tarefa:

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

Coletar cobertura de código

Ao criar na plataforma Windows, você pode coletar métricas de cobertura de código usando o coletor de dados de cobertura interno. O projeto de teste deve fazer referência a Microsoft.NET.Test.SDK versão 15.8.0 ou superior.

Quando você usa a tarefa .NET Core (DotNetCoreCLI@2) para executar testes, os dados de cobertura são publicados automaticamente no servidor. Você pode baixar o arquivo *.coverage do resumo da compilação para exibir no Visual Studio.

Para coletar cobertura de código, adicione o --collect "Code Coverage" argumento quando adicionar a tarefa de teste ao pipeline.

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

Se você usar o assistente de tarefas para adicionar a tarefa .NET Core (DotNetCoreCLI@2), defina as seguintes propriedades:

• Comando: teste
• Caminho para projetos: defina para os projetos de teste em sua solução
• Argumentos: --configuration $(BuildConfiguration) --collect "Code Coverage"

Verifique se a opção Publicar resultados do teste permanece selecionada.

Como alternativa, para coletar resultados de cobertura de código usando o dotnet test comando com um registrador específico e, em seguida, executar a tarefa PublishTestResults@2 , use o seguinte código:

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'

Colete métricas de cobertura de código com o Coverlet

Se você compilar em Linux ou macOS, poderá usar o Coverlet ou uma ferramenta semelhante para coletar métricas de cobertura de código.

Você pode publicar resultados de cobertura de código no servidor com a tarefa Publicar resultados de cobertura de código (PublishCodeCoverageResults@2 ). Você deve configurar a ferramenta de cobertura para gerar resultados no formato de cobertura Cobertura ou JaCoCo.

Para executar testes e publicar cobertura de código com o Coverlet:

1. Adicione uma referência ao coverlet.collector pacote NuGet.
2. Adicione o seguinte trecho ao seu arquivo 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'

Embale e entregue o seu código

Para empacotar e entregar sua saída de compilação, você pode:

• Publique seus artefatos de compilação no Azure Pipelines.
• Crie um pacote NuGet e publique-o no seu feed NuGet.
• Publique seu pacote NuGet no Azure Artifacts.
• Crie um arquivo ZIP para implantar em um aplicativo Web.
• Publique símbolos em um servidor de símbolos de Artefatos do Azure ou em um compartilhamento de arquivos.

Você também pode criar uma imagem para seu aplicativo e enviá-la por push para um registro de contêiner.

Publicar artefatos no Azure Pipelines

Para publicar a saída da compilação do .NET no pipeline, siga estas etapas.

1. Execute dotnet publish --output $(Build.ArtifactStagingDirectory) usando a CLI do .NET ou adicione a tarefa .NET Core (DotNetCoreCLI@2) com o comando publishing .
2. Publique o artefato usando a tarefa Publish Pipeline Artifact (PublishPipelineArtifact@1 ). Esta tarefa carrega todos os arquivos como $(Build.ArtifactStagingDirectory) um artefato de sua compilação.

Adicione o seguinte código ao seu arquivo 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 mais arquivos para o diretório de compilação antes de publicar, use a tarefa Copiar arquivos (CopyFile@2 ).

Nota

A publishWebProjects entrada na tarefa .NET Core (DotNetCoreCLI@2) é definida como true padrão e publica todos os projetos da Web em seu repositório. Para obter mais informações, consulte o repositório do GitHub azure-pipelines-tasks .

Para obter mais informações, consulte Publicar e baixar artefatos de compilação.

Publicar em um feed do NuGet

Para criar um pacote NuGet e publicá-lo em seu feed do NuGet, adicione o seguinte trecho ao seu arquivo 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

A NuGetAuthenticate@1 tarefa não oferece suporte à autenticação de chave de API NuGet. Se você estiver usando uma chave de API do NuGet, use a NuGetCommand@2 tarefa com a command entrada definida como push e o --api-key argumento. Por exemplo, dotnet nuget push --api-key $(NuGetApiKey).

Para obter mais informações sobre controle de versão e publicação de pacotes NuGet, consulte Publicar pacotes NuGet com pipelines do Azure.

Publicar um pacote NuGet nos Artefatos do Azure

Você pode publicar seus pacotes NuGet em seu feed de Artefatos do Azure usando a tarefa NuGetCommand@2 . Para obter mais informações, consulte Publicar pacotes NuGet com o Azure Pipelines.

Publicar um arquivo ZIP em um aplicativo Web

Para criar um arquivo ZIP pronto para publicação em um aplicativo Web, adicione o seguinte trecho ao azure-pipelines.yml. Execute essa tarefa depois de criar seu aplicativo, perto do final do pipeline na maioria dos casos. Por exemplo, execute esta tarefa antes de implantar em um aplicativo Web do Azure no Windows.

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

Para publicar esse arquivo em um aplicativo Web, consulte Implantação de aplicativos Web do Azure.

Publicar símbolos

Você pode usar a PublishSymbols@2 tarefa para publicar símbolos em um servidor de símbolos de Artefatos do Azure ou em um compartilhamento de arquivos. Para obter mais informações, consulte Publicar símbolos.

Por exemplo, para publicar símbolos em um compartilhamento de arquivos, adicione o seguinte trecho ao arquivo azure-pipelines.yml :

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

Para usar o editor clássico, adicione a tarefa Fontes de índice e publicar símbolos ao seu pipeline.

Solução de problemas

Se o seu projeto for compilado com êxito na sua máquina local, mas não nos Pipelines do Azure, explore as seguintes causas potenciais e ações corretivas.

• As versões de pré-lançamento do SDK do .NET Core não são instaladas em agentes hospedados pela Microsoft, e a implantação de uma nova versão do SDK em todos os data centers do Azure Pipelines pode levar algumas semanas. Em vez de aguardar a conclusão de uma distribuição, você pode usar a tarefa Usar .NET Core para instalar a versão do SDK do .NET Core desejada em agentes hospedados pela Microsoft.

• Uma nova versão do SDK do .NET Core ou do Visual Studio pode quebrar a compilação, por exemplo, se ela contiver uma versão mais recente ou um recurso da ferramenta NuGet. Verifique se as versões e o tempo de execução do SDK do .NET Core em sua máquina de desenvolvimento correspondem ao agente de pipeline.

  Você pode incluir um dotnet --version script de linha de comando em seu pipeline para imprimir a versão do SDK do .NET Core. Use o .NET Core Tool Installer para implantar a mesma versão no agente ou atualize seus projetos e máquina de desenvolvimento para a versão de pipeline do SDK do .NET Core.

• Suas compilações podem falhar intermitentemente devido a problemas de conexão quando você restaura pacotes do NuGet.org. NuGet.org pode estar tendo problemas ou pode haver problemas de rede entre o data center do Azure e NuGet.org. Você pode explorar se o uso de Artefatos do Azure com fontes upstream para armazenar em cache os pacotes melhora a confiabilidade de suas compilações.

  As credenciais do pipeline são usadas automaticamente para se conectar aos Artefatos do Azure. Essas credenciais geralmente são derivadas da conta do Serviço de Compilação da Coleção de Projetos. Para saber mais sobre como usar os Artefatos do Azure para armazenar em cache seus pacotes NuGet, consulte Conectar-se aos feeds de Artefatos do Azure.

• Você pode estar usando alguma lógica no Visual Studio que não está codificada em seu pipeline. O Azure Pipelines executa cada comando em uma tarefa sequencialmente em um novo processo. Examine os logs da compilação de pipelines para ver os comandos exatos executados na compilação. Para localizar o problema, repita os mesmos comandos na mesma ordem na máquina de desenvolvimento.

• Se você tiver uma solução mista que inclua alguns projetos .NET Core e alguns projetos .NET Framework, use a tarefa NuGet para restaurar pacotes especificados nos arquivos packages.config . Adicione a tarefa MSBuild ou Visual Studio Build para criar os projetos do .NET Framework.

Conteúdo relacionado

• Artefatos do Azure
• Tarefas de compilação e liberação
• Ferramentas da CLI do .NET Core
• Teste de unidade em projetos .NET Core