Criar, testar e implantar projetos do .NET Core

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

Este artigo descreve como usar o Azure Pipelines para trabalhar com projetos do .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 build com agentes hospedados pela Microsoft ou auto-hospedados.
• 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 SDK do .NET ao pipeline.
• Use a tarefa Publicar Resultados de Cobertura de Código (Publish code coverage results v2) para publicar resultados de cobertura de código.
• Empacotar e entregar sua saída de build para o pipeline, um feed do NuGet, um arquivo ZIP ou outros destinos.

Observação

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 do Azure DevOps. É possível criar uma gratuitamente.
• Associação ao grupo administradores de projeto da organização, para que você possa criar projetos do Azure DevOps e conceder acesso ao projeto a pipelines. Os proprietários da organização do Azure DevOps têm essa associação automaticamente.
• Um projeto do Azure DevOps 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. Essa solicitação pode levar vários dias úteis para ser processada. 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 do Projeto.
• Uma conta do GitHub e um repositório.

Criar um projeto do .NET e carregá-lo no GitHub

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

Se você não tiver um projeto .NET com o qual trabalhar, crie um novo em seu computador local da seguinte maneira:

1. Instale o SDK do .NET 8.0 ou verifique se ele está instalado.
2. Abra uma janela do terminal em seu computador local.
3. Crie um diretório do projeto e acesse-o.
4. Crie um novo aplicativo Web .NET 8 executando dotnet new webapp -f net8.0.
5. Compile e execute o aplicativo localmente usando dotnet run.
6. Quando o aplicativo for iniciado, pressione Ctrl+C para desligá-lo.
7. Carregue ou conecte o projeto local ao repositório GitHub.

Criar um pipeline

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 à esquerda.

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

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

4. Você pode ser redirecionado para o GitHub para então entrar. Nesse caso, insira suas credenciais do GitHub.

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

6. Você poderá ser redirecionado ao GitHub para instalar o aplicativo do Azure Pipelines. Se sim, selecione Aprovar e instalar.

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

   Você também pode selecionar o pipeline Starter na guia Configurar para começar com um pipeline mínimo e adicionar as etapas e as configurações por conta própria.

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

9. Ao final, selecione Salvar e executar.

   

10. Opcionalmente, edite a mensagem commit e selecione Salvar e executar novamente.

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

Clássico

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

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

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

   Observação

   A capacidade de criar pipelines clássicos é desativada por padrão para novas organizações e projetos do Azure DevOps. Se você não vir a opção de usar o editor clássico, desative a criação de pipelines de build clássicos e desabilite a criação de opções de pipelines de lançamento clássicos nasConfigurações de> de > da Organização e/ouConfigurações de>> do Project.

4. Em Selecionar uma origem, selecione GitHub.

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

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

7. Selecione Continuar.

8. Na tela Selecionar um modelo , pesquise e selecione o modelo ASP.NET Core e 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 build.

   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 , no pool do Agente, selecione Azure Pipelines 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 o 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 a instalar o SDK do .NET.

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

Configurar o ambiente de compilação

Você pode criar seus projetos do .NET Core usando o SDK do .NET Core e o runtime para Windows, Linux ou macOS. Por padrão, seus builds são executados 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 os agentes hospedados pela Microsoft para obter uma lista completa de imagens e exemplos de configuração disponíveis.

O snippet de pipeline yaml a seguir define o sistema operacional Ubuntu 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 runtime do .NET Core. Para instalar um SDK mais recente, defina performMultiLevelLookuptrue como no seguinte snippet:

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

Agentes auto-hospedados

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

Agentes auto-hospedados permitem que você:

• Evite o custo de execução do UseDotNet@2 instalador de ferramentas.
• Diminua o tempo de build se você tiver um repositório grande.
• Execute builds incrementais.
• Use SDKs privados ou de visualização que a Microsoft não dá suporte oficialmente.
• Use SDKs disponíveis somente em seus ambientes corporativos ou locais.

Para obter mais informações, confira Agentes auto-hospedados.

Restaurar dependências

Os pacotes NuGet são uma maneira de seu projeto depender do código que você não cria. Você pode baixar pacotes NuGet e ferramentas específicas do projeto executando o dotnet restore comando, 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 do .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 o pipeline, você não precisará se autenticar. Para obter mais informações, consulte Tarefa do .NET Core (DotNetCoreCLI@2).

Ao usar agentes hospedados pela Microsoft, você obtém uma nova máquina sempre que executa uma compilação, que restaura os pacotes a cada execução. A restauração pode demorar consideravelmente. Para atenuar esse problema, use o Azure Artifacts ou um agente auto-hospedado para aproveitar o cache de pacotes.

O pipeline a seguir usa a DotNetCoreCLI@2 tarefa para restaurar um feed do 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)'

No SDK do .NET Core 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 emconexões do Serviço de> de > do Projeto. Para obter mais informações sobre conexões de serviço do NuGet, consulte Publicar pacotes NuGet com o Azure Pipelines.

Restaurar pacotes de NuGet.org

Para restaurar pacotes de NuGet.org, atualize o pipeline da seguinte maneira.

YAML

Você pode adicionar o comando de restauração ao pipeline editando o código YAML diretamente ou usando o assistente de tarefa.

Adicione a tarefa do .NET Core (DotNetCoreCLI@2) diretamente inserindo o snippet a seguir no arquivo azure-pipelines.yml antes das tarefas de build.

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 o .NET Core no catálogo de tarefas.
3. Na tela de configuração, selecione restaurar na lista suspensa Comando .
4. No campo Caminho para projetos ou solução , insira o caminho para seus arquivos *.csproj . Você pode usar o curinga **/*.csproj para todos os arquivos *.csproj em todas as subpastas.
5. Para que os Feeds sejam adicionados, verifique se os Feeds que seleciono aqui e usar pacotes de NuGet.org estão selecionados.
6. Selecione Adicionar.
7. Selecione Validar e salvar e, em seguida, selecione Salvar para confirmar a alteração.

Clássico

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

1. Na guia Tarefas no pipeline, selecione o trabalho do Agente 1 ou outro trabalho que executa suas tarefas de build.
2. Selecione + para adicionar uma nova tarefa a esse trabalho.
3. No catálogo de tarefas, selecione .NET Core e, em seguida, selecione Adicionar.
4. No painel esquerdo, selecione a tarefa de build do dotnet adicionada para abrir o editor de tarefas.
5. Selecione a restauração na lista suspensa Comando . O nome de exibição é alterado para restauração do dotnet.
6. No campo Caminho para projetos ou solução , insira o caminho para seus arquivos *.csproj . Você pode usar o curinga **/*.csproj para todos os arquivos *.csproj em todas as subpastas.
7. Para que os Feeds sejam adicionados, verifique se os Feeds que seleciono aqui e usar pacotes de NuGet.org estão selecionados.
8. No painel esquerdo, arraste a tarefa para posicioná-la antes da tarefa Build .
9. Na parte superior da página, selecione Salvar & Salvar fila>.

Restaurar pacotes de um feed externo

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

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

YAML

Adicione a tarefa do .NET Core (DotNetCoreCLI@2) diretamente inserindo o snippet a seguir no arquivo azure-pipelines.yml antes das tarefas de build. 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 adicionar feeds, selecione Feeds no meu NuGet.config.
3. Em Caminho para NuGet.config, insira o caminho para o arquivo NuGet.config , em relação à 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 dessa organização/coleção, selecione as credenciais a serem usadas para registros externos no arquivo NuGet.config selecionado. Para feeds na mesma organização, você pode deixar esse campo em branco. As credenciais do build são usadas automaticamente.

Clássico

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

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

3. Em Caminho para NuGet.config, insira o caminho para o arquivo NuGet.config , em relação à 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 dessa 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 do build são usadas automaticamente.

   Você pode selecionar Gerenciar para acessar as configurações do projeto e selecionar a conexão. Você também pode selecionar Novo para criar uma conexão de serviço. Marque a caixa de seleção para 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'

Observação

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

Compilar o projeto

Crie seu projeto do .NET Core executando o dotnet build comando. Você pode adicionar o comando ao 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 build 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 snippet a seguir. Atualize para arguments atender à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 o build na lista suspensa Comando .
4. No campo Caminho para projetos ou solução , 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 build usando o editor clássico.

1. Na guia Tarefas no pipeline, selecione o trabalho do Agente 1 ou outro trabalho que executa suas tarefas de build.
2. Selecione + para adicionar uma nova tarefa a esse trabalho.
3. No catálogo de tarefas, selecione .NET Core e, em seguida, selecione Adicionar.
4. No painel esquerdo, selecione a tarefa de build do dotnet adicionada para abrir o editor de tarefas. O campo Comando já mostra o build.
5. No campo Caminho para projetos ou solução , insira o caminho para seus arquivos *.csproj . Você pode usar o curinga **/*.csproj para todos os arquivos *.csproj em todas as subpastas.
6. Para que os Feeds sejam adicionados, verifique se os Feeds que seleciono 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 & Salvar fila>.

Criar 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 build 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 tarefa 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. Em Diretório de Trabalho Avançado>, insira o caminho para o arquivo *.csproj como o diretório de trabalho. Se você deixá-lo em branco, o diretório de trabalho usará como padrão $(Build.SourcesDirectory).
5. Selecione Adicionar.
6. Selecione Salvar para confirmar a alteração.

Clássico

Para adicionar uma linha de comando de build usando o editor clássico:

1. Na guia Tarefas no pipeline, selecione o trabalho do Agente 1 ou outro trabalho que executa suas tarefas de build.
2. Selecione + para adicionar uma nova tarefa a esse trabalho.
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 de exibição , se desejado.
6. Em Script, insira o dotnet build comando com parâmetros. Por exemplo, dotnet build --configuration $(buildConfiguration).
7. Em Diretório de Trabalho Avançado>, 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 & Salvar fila>.

Adicionar outros comandos do SDK do .NET ao pipeline

Você pode adicionar outros comandos do SDK do .NET ao 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 que você adicione facilmente comandos da CLI do .NET ao 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 tarefa no editor de pipeline do YAML, execute as seguintes etapas:

1. Vá para a posição no arquivo YAML onde você deseja inserir a tarefa.
2. Selecione o .NET Core no catálogo de tarefas.
3. Selecione o comando que você deseja executar na lista suspensa no campo Comando .
4. Configure todas 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 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 no pipeline, selecione o trabalho do Agente 1 ou outro trabalho que executa suas tarefas de build.
2. Selecione + para adicionar uma nova tarefa a esse trabalho.
3. No catálogo de tarefas, selecione .NET Core e, em seguida, selecione Adicionar.
4. No painel esquerdo, selecione a tarefa de build do dotnet adicionada para abrir o editor de tarefas.
5. Edite o nome de exibição conforme desejado. O nome da tarefa no painel esquerdo é atualizado adequadamente.
6. Em Comando, selecione o comando que você deseja executar, como personalizado.
7. Configure todas 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 & Salvar fila>.

Instalar uma ferramenta

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

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

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

Executar seus testes

Quando você tiver projetos de teste em seu repositório, poderá 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 referenciar o 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 do build. Você pode usar os resultados do teste para solucionar problemas de testes com falha e analisar o tempo de teste.

Para adicionar uma tarefa de teste ao pipeline, adicione o seguinte snippet 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 tarefa para adicionar a tarefa .NET Core (DotNetCoreCLI@2), defina as seguintes propriedades:

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

Como alternativa, você pode executar o dotnet test comando com um agente 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 referenciar o 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 do build para exibir no Visual Studio.

Para coletar a cobertura de código, adicione o --collect "Code Coverage" argumento ao 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 tarefa para adicionar a tarefa .NET Core (DotNetCoreCLI@2), defina as seguintes propriedades:

• Comando: teste
• Caminho para projetos: definir 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 agente 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'

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

Se você criar no 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 a cobertura de código com o Coverlet:

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

Empacotar e entregar seu código

Para empacotar e entregar a saída do build, você pode:

• Publique seus artefatos de build no Azure Pipelines.
• Crie um pacote NuGet e publique-o no feed do 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 do Azure Artifacts ou em um compartilhamento de arquivos.

Você também pode criar uma imagem para o seu aplicativo e enviá-la a um registro do contêiner.

Publicar artefatos no Azure Pipelines

Para publicar a saída do build 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 de publicação .
2. Publique o artefato usando a tarefa Publicar Artefato do Pipeline (PublishPipelineArtifact@1 ). Essa tarefa carrega todos os arquivos $(Build.ArtifactStagingDirectory) como um artefato do seu build.

Adicione o seguinte código ao 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).

Observação

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

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

Publique em um feed do NuGet

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

Observação

A NuGetAuthenticate@1 tarefa não dá suporte à autenticação de chave da API do NuGet. Se você estiver usando uma chave de API do NuGet, use a NuGetCommand@2 tarefa com o command conjunto push de entrada 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 o Azure Pipelines.

Publicar um pacote do NuGet no Azure Artifacts

Você pode publicar seus pacotes NuGet no feed do Azure Artifacts 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 que esteja pronto para publicar em um aplicativo Web, adicione o snippet a seguir ao azure-pipelines.yml. Execute essa tarefa depois de criar seu aplicativo, perto do final do pipeline na maioria dos casos. Por exemplo, execute essa 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, confira Implantação de Aplicativo Web do Azure.

Publicar símbolos

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

Por exemplo, para publicar símbolos em um compartilhamento de arquivos, adicione o seguinte snippet 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 as fontes de índice e publique a tarefa de símbolos ao pipeline.

Resolução de problemas

Se o projeto for criado com êxito em seu computador local, mas não no Azure Pipelines, explore as possíveis causas e ações corretivas a seguir.

• As versões de pré-lançamento do SDK do .NET Core não são instaladas em agentes hospedados pela Microsoft e a distribuição de uma nova versão do SDK para 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 interromper o build, por exemplo, se ele contiver uma versão ou recurso mais recente da ferramenta NuGet. Verifique se as versões e o runtime do SDK do .NET Core em seu computador 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 Instalador de Ferramentas do .NET Core para implantar a mesma versão no agente ou atualize seus projetos e seu computador de desenvolvimento para a versão de pipeline do SDK do .NET Core.

• Seus builds podem falhar intermitentemente devido a problemas de conexão ao restaurar pacotes de NuGet.org. NuGet.org pode estar tendo problemas ou pode haver problemas de rede entre o data center do Azure e o NuGet.org. Você pode explorar se o uso do Azure Artifacts com fontes upstream para armazenar em cache os pacotes melhora a confiabilidade de seus builds.

  As credenciais do pipeline são usadas automaticamente para se conectar ao Azure Artifacts. Normalmente, essas credenciais são derivadas da conta do Serviço de Build da Coleção de Projetos. Para saber mais sobre como usar o Azure Artifacts para armazenar em cache seus pacotes do NuGet, consulte Conectar a feeds do Azure Artifacts.

• 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 do build de pipelines para ver os comandos exatos executados no build. Para localizar o problema, repita os mesmos comandos na mesma ordem em seu computador de desenvolvimento.

• Se você tiver uma solução mista que inclua alguns projetos do .NET Core e alguns projetos do .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 .NET Framework.

Conteúdo relacionado

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