Criar, testar e implementar aplicações .NET Core

Serviços de DevOps do Azure | Azure DevOps Server 2022 - Azure DevOps Server 2019

Use um Pipeline do Azure para criar, testar e implantar automaticamente seus projetos .NET Core. Este artigo mostra como executar as seguintes tarefas:

Pré-requisitos

Create your first pipeline (Criar o primeiro pipeline)

Você é novo no Azure Pipelines? Em caso afirmativo, recomendamos que tente primeiro a secção seguinte.

Criar um projeto .NET

Se você não tiver um projeto .NET para trabalhar, crie um novo em seu sistema local. Comece instalando o SDK mais recente do .NET 8.0 .

1. Abra uma janela do terminal.

2. Crie um diretório de projeto e navegue até ele.

3. Crie um novo aplicativo Web .NET 8.

   dotnet new webapp -f net8.0
   

4. Na mesma sessão de terminal, execute o aplicativo localmente usando o dotnet run comando do diretório do projeto.

   dotnet run
   

5. Depois que o aplicativo for iniciado, pressione Ctrl-C para desligá-lo.

Crie um repositório git e conecte-o ao GitHub

1. A partir do diretório do projeto, crie um repositório git local e confirme o código do aplicativo na ramificação principal.

2. Conecte seu repositório Git local a um repositório GitHub.

Criar um projeto de DevOps

Configurar seu ambiente de compilação

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

Crie seu pipeline

Você pode usar o editor de pipeline YAML ou o editor clássico para criar seu pipeline. Para usar o editor clássico, selecione Usar o editor clássico.

Agora você tem um pipeline de trabalho pronto para você personalizar! Leia mais para aprender algumas das maneiras comuns de personalizar seu pipeline.

Ambiente de construção

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

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

pool:
  vmImage: 'ubuntu-latest' 

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

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

Restaurar dependências

O NuGet é uma maneira popular de depender de código que você não cria. Você pode baixar pacotes NuGet e ferramentas específicas do projeto especificadas no arquivo de projeto executando o dotnet restore comando por meio da tarefa .NET Core ou diretamente em um script em seu pipeline. Para obter mais informações, consulte Tarefa .NET Core (DotNetCoreCLI@2).

Você pode baixar pacotes NuGet do Azure Artifacts, NuGet.org ou algum outro repositório NuGet externo ou interno. A tarefa .NET Core é especialmente útil para restaurar pacotes de feeds NuGet autenticados. Se o feed estiver no mesmo projeto que o pipeline, não será necessário autenticar.

Esse pipeline usa um feed de Artefato do Azure para dotnet restore a tarefa DotNetCoreCLI@2 .

trigger:
- main

pool:
  vmImage: 'windows-latest'

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

variables:
  buildConfiguration: 'Release'

steps:
- task: DotNetCoreCLI@2
  inputs:
    command: 'restore'
    feedsToUse: 'select'
    vstsFeed: 'my-vsts-feed' # A series of numbers and letters

- task: DotNetCoreCLI@2
  inputs:
    command: 'build'
    arguments: '--configuration $(buildConfiguration)'
  displayName: 'dotnet build $(buildConfiguration)'

O dotnet restore comando usa o NuGet.exe empacotado com o SDK do .NET Core e só pode restaurar pacotes especificados nos arquivos de projeto .csproj do .NET Core.

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 NuGet para restaurar essas dependências.

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

No .NET Core SDK versão 2.0 e mais recente, os pacotes são restaurados automaticamente ao executar comandos como dotnet build. No entanto, você ainda precisará usar a tarefa .NET Core para restaurar pacotes se usar um feed autenticado.

Suas compilações podem falhar devido a problemas de conexão quando você restaura pacotes do NuGet.org. Você pode usar os Artefatos do Azure com fontes upstream para armazenar os pacotes em cache. As credenciais do pipeline são usadas automaticamente quando ele se conecta 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.

Para especificar um repositório NuGet, coloque a URL em um NuGet.config arquivo no repositório. Se o feed for autenticado, gerencie suas credenciais criando uma conexão de serviço NuGet na guia Serviços em Configurações do projeto.

Para obter mais informações sobre conexões de serviço NuGet, consulte publicar em feeds NuGet.

Restaurar pacotes a partir de um feed externo

Faça o seguinte para restaurar pacotes de um feed externo.

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

Construa o seu projeto

Crie seus projetos .NET Core executando o dotnet build comando. Você pode adicionar o comando ao seu pipeline como um script de linha de comando ou usando a tarefa .NET Core.

Compilação do .NET Core usando a tarefa .NET Core

Exemplo de YAML para criar usando a tarefa DotNetCoreCLI@2:

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

Compilação do .NET Core usando script de linha de comando

Exemplo de YAML para construir usando dotnet build como um script:

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

Adicionar comandos do SDK do .NET ao seu pipeline

Você pode adicionar comandos do SDK do .NET ao seu projeto como um script ou usando a tarefa .NET Core. A tarefa .NET Core (DotNetCoreCLI@2) permite que você adicione facilmente comandos da CLI dotnet ao seu pipeline. Você pode adicionar tarefas do .NET Core editando seu arquivo YAML ou usando o editor clássico.

Adicionar um comando .NET CLI usando a tarefa .NET Core

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

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

Exemplo:

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

Instalar uma ferramenta

Para instalar uma ferramenta global do .NET Core como dotnetsay em sua compilação em execução no Windows, execute as seguintes etapas:

1. Adicione a tarefa .NET Core e defina as seguintes propriedades:
   • Comando: personalizado.
     • Caminho para projetos: deixe em branco.
   • Comando personalizado: ferramenta.
   • Argumentos: install -g dotnetsay.
2. Para executar a ferramenta, adicione uma linha de comando e defina as seguintes propriedades:
   • Roteiro: dotnetsay.

Execute os testes

Quando você tem projetos de teste em seu repositório, você pode usar a tarefa .NET Core 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 dos testes são publicados automaticamente no serviço. Esses resultados estão disponíveis para você no resumo da compilação e podem ser usados para solucionar problemas de testes com falha e análise de tempo de teste.

Você pode adicionar uma tarefa de teste ao seu pipeline usando a tarefa DotNetCoreCLI@2 ou adicionar o seguinte trecho ao seu azure-pipelines.yml arquivo:

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

Ao usar o editor de tarefas do .NET Core , defina Command para testar e Path to projects deve se referir aos projetos de teste em sua solução.

Como alternativa, você pode executar o dotnet test comando com um registrador específico e, em seguida, usar a tarefa Publicar resultados do teste:

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'

Coletar cobertura de código

Quando você está criando na plataforma Windows, as métricas de cobertura de código podem ser coletadas 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 para executar testes, os dados de cobertura são publicados automaticamente no servidor. O .coverage arquivo pode ser baixado do resumo da compilação para exibição no Visual Studio.

Adicione o seguinte trecho ao seu azure-pipelines.yml arquivo:

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

Para adicionar a tarefa .NET Core através do editor de tarefas:

1. Adicione a tarefa .NET Core ao seu trabalho de compilação e defina as seguintes propriedades:

   1. Comando: testar.
   2. Caminho para projetos: Deve consultar os projetos de teste em sua solução.
   3. Argumentos: --configuration $(BuildConfiguration) --collect "Code coverage".

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

Se você optar por executar o dotnet test comando, especifique o registrador de resultados de teste e as opções de cobertura. Em seguida, use a tarefa Publicar resultados do teste:

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'

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

Se você estiver criando 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@1 ). A ferramenta de cobertura deve ser configurada para gerar resultados no formato de cobertura Cobertura ou JaCoCo.

Para executar testes e publicar cobertura de código com o Coverlet, execute as seguintes tarefas:

• Adicione uma referência ao coverlet.collector pacote NuGet.

• Adicione o seguinte trecho ao seu azure-pipelines.yml arquivo:

  - task: UseDotNet@2
    inputs:
      version: '8.x'
      includePreviewVersions: true # Required for preview versions
  
  - task: DotNetCoreCLI@2
    displayName: 'dotnet build'
    inputs:
      command: 'build'
      configuration: $(buildConfiguration)
  
  - task: DotNetCoreCLI@2
    displayName: 'dotnet test'
    inputs:
      command: 'test'
      arguments: '--configuration $(buildConfiguration) --collect:"XPlat Code Coverage" -- DataCollectionRunSettings.DataCollectors.DataCollector.Configuration.Format=cobertura'
      publishTestResults: true
      projects: 'MyTestLibrary' # update with your test project directory
  
  - task: PublishCodeCoverageResults@1
    displayName: 'Publish code coverage report'
    inputs:
      codeCoverageTool: 'Cobertura'
      summaryFileLocation: '$(Agent.TempDirectory)/**/coverage.cobertura.xml'
  

Embale e entregue o seu código

Você pode publicar seus artefatos de construção ao:

• Publicação no Azure Pipelines.
• Publicando pacotes no Azure Artifacts.
• Criar um pacote NuGet e publicar no seu feed NuGet.
• Criar um arquivo .zip para implantar seu aplicativo Web.

Publicar artefatos no Azure Pipelines

steps:

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

# this code takes all the files in $(Build.ArtifactStagingDirectory) and uploads them as an artifact of your build.
- task: PublishPipelineArtifact@1
  inputs:
    targetPath: '$(Build.ArtifactStagingDirectory)' 
    artifactName: 'myWebsite'

steps:

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

# this code takes all the files in $(Build.ArtifactStagingDirectory) and uploads them as an artifact of your build.
- task: PublishBuildArtifacts@1
  inputs:
    PathtoPublish: '$(Build.ArtifactStagingDirectory)'
    ArtifactName: 'drop'

Publicar em um feed do NuGet

Para criar um pacote NuGet e publicá-lo em seu feed NuGet, adicione o seguinte trecho:

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

Para obter mais informações sobre controle de versão e publicação de pacotes NuGet, consulte Publicar em feeds NuGet.

Publicar um pacote NuGet nos Artefatos do Azure

Você pode publicar seus pacotes NuGet em seu feed de Artefatos do Azure usando o NuGetCommand@2 para enviar por push para seu feed de Artefatos do Azure. Por exemplo, consulte Publicar pacotes NuGet com o Azure Pipelines.

Implementar uma aplicação Web

Para criar um arquivo .zip pronto para publicação em um aplicativo Web, adicione o seguinte trecho:

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 esse arquivo em um aplicativo Web, consulte Implantação de aplicativos Web do Azure.

Criar uma imagem e enviar por push para o registro de contêiner

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

Publicar símbolos

Você pode usar a tarefa PublishSymbols@2 para publicar símbolos em um servidor de símbolos de Artefatos do Azure ou em um compartilhamento de arquivos.

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'

Ao usar o editor clássico, selecione Fontes de índice publicar símbolos do catálogo de tarefas para adicionar ao seu pipeline.

Para obter mais informações, consulte Publicar símbolos.

Resolver problemas

Se você puder criar seu projeto em sua máquina de desenvolvimento, mas estiver tendo problemas para criá-lo no Azure Pipelines, explore as seguintes causas potenciais e ações corretivas:

• Verifique as versões e o tempo de execução do SDK do .NET Core em sua máquina de desenvolvimento e verifique se eles correspondem ao agente. Você pode incluir um script dotnet --version 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 mais recente do SDK do .NET Core.

• Você pode estar usando alguma lógica no IDE do Visual Studio que não está codificada em seu pipeline. O Azure Pipelines executa cada um dos comandos especificados nas tarefas, um após o outro, em um novo processo. Examine os logs da compilação de pipelines para ver os comandos exatos que foram executados como parte da compilação. Repita os mesmos comandos na mesma ordem na máquina de desenvolvimento para localizar o problema.

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

• Suas compilações podem falhar intermitentemente durante a restauração de pacotes: NuGet.org está tendo problemas ou há problemas de rede entre o data center do Azure e NuGet.org. Você pode explorar se o uso de Artefatos do Azure com NuGet.org como uma fonte upstream melhora a confiabilidade de suas compilações, pois não está sob nosso controle.

• Ocasionalmente, quando uma nova versão do SDK do .NET Core ou do Visual Studio é lançada, sua compilação pode quebrar. Por exemplo, uma versão mais recente ou um recurso da ferramenta NuGet fornecido com o SDK pode quebrar sua compilação. Para isolar esse problema, use a tarefa .NET Core Tool Installer para especificar a versão do SDK do .NET Core usada em sua compilação.

FAQ

P: Onde posso saber mais sobre os Artefatos do Azure?

R: Gerenciamento de Pacotes em Artefatos do Azure

P: Onde posso saber mais sobre os comandos do .NET Core?

R: Ferramentas da CLI do .NET Core

P: Onde posso saber mais sobre a execução de testes na minha solução?

R: Teste de unidade em projetos .NET Core

P: Onde posso saber mais sobre as tarefas?

R: Tarefas de compilação e liberação