Criar, testar e implantar aplicativos .NET Core

Azure DevOps Services | Azure DevOps Server 2022 - Azure DevOps Server 2019

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

Pré-requisitos

Crie seu primeiro pipeline

Você é iniciante no Azure Pipelines? Nesse caso, recomendamos que você tente usar a seção a seguir primeiro.

Criar um projeto .NET

Se você não tiver um projeto .NET com o qual 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 do projeto e acesse-o.

3. Crie um aplicativo Web .NET 8.

   dotnet new webapp -f net8.0
   

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

   dotnet run
   

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

Criar um repositório git e conectá-lo ao GitHub

1. No 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 o ambiente de compilação

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

Criar o 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 personalização! Leia mais para conhecer algumas das maneiras comuns de personalizar seu pipeline.

Ambiente de build

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 do código que você não cria. Você pode baixar pacotes NuGet e ferramentas específicas do projeto que são especificadas no arquivo de projeto, executando o comando dotnet restore por meio da tarefa .NET Core ou diretamente em um script no seu pipeline. Para obter mais informações, consulte Tarefa do .NET Core (DotNetCoreCLI@2).

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

Esse pipeline usa um feed de Artefato do Azure para dotnet restore na 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 comando dotnet restore usa o SDK do Core NuGet.exe compactado com o SDK do Core .NET e só pode restaurar pacotes especificados nos arquivos .csproj do .NET Core do projeto.

Se você também tiver um projeto do Microsoft .NET Framework na 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 SDK do .NET Core 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 do .NET Core para restaurar pacotes, se você usar um feed autenticado.

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

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

Para obter mais informações sobre conexões de serviço do NuGet, confira Publicar em feeds do NuGet.

Restaurar pacotes 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>

Compilar o projeto

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

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

Exemplo de YAML para compilar 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 compilar usando dotnet build como um script:

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

Adicionar comandos do SDK do .NET ao pipeline

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

Adicionar um comando da CLI do .NET usando a tarefa do .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 arquivo azure-pipelines.yml.

Exemplo:

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

Instalar uma ferramenta

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

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

Executar seus testes

Quando você tiver projetos de teste em seu repositório, use a tarefa do .NET Core 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. Esses resultados estão disponíveis no resumo do build 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 pipeline usando a tarefa DotNetCoreCLI@2 ou adicionar o seguinte trecho ao arquivo azure-pipelines.yml:

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 o comando como test, e o Caminho para os projetos devem se referir aos projetos de teste na solução.

Você também pode executar o comando dotnet test 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 referenciar o Microsoft.NET.Test.SDK versão 15.8.0 ou superior.

Quando você usa a tarefa do .NET Core para executar testes, os dados de cobertura são publicados automaticamente no servidor. O arquivo .coverage pode ser baixado do resumo de compilação para exibição no Visual Studio.

Adicione o snippet de código a seguir ao seu arquivo azure-pipelines.yml:

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

Para adicionar a tarefa do .NET Core pelo editor de tarefas:

1. Adicione a tarefa .NET Core ao trabalho de build e defina as seguintes propriedades:

   1. Comando: test.
   2. Caminho para projetos: deve se referir aos projetos de teste na 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 comando dotnet test, especifique o agente de resultados do 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'

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

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

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

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

• Adicione o snippet de código a seguir ao seu arquivo azure-pipelines.yml:

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

Empacotar e entregar seu código

Para publicar seus artefatos de compilação:

• Publique-os nos pipelines do Azure.
• Publique pacotes no Azure Artifacts.
• Criar um pacote do NuGet e publicar no seu feed do 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'

Publique em um feed do NuGet

Para criar um pacote do NuGet e publicá-lo em seu feed do 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, confira Publicar nos feeds NuGet.

Publicar um pacote do NuGet no Azure Artifacts

Você pode publicar seus pacotes do NuGet em seu feed do Azure Artifacts usando NuGetCommand@2 para enviar por push para seu feed do Azure Artifacts. Por exemplo, consulte Publicar pacotes do NuGet com os pipelines do Azure.

Implantar um aplicativo Web

Para criar um arquivo .zip que esteja 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, confira Implantação de Aplicativo Web do Azure.

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

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

Publicar símbolos

Você pode usar a tarefa PublishSymbols@2 para publicar símbolos em um servidor de símbolos do Azure Artifacts 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 Símbolos de publicação de fontes de índice no catálogo de tarefas a serem adicionados ao pipeline.

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

Solucionar problemas

Se você puder criar seu projeto no seu computador de desenvolvimento, mas estiver tendo problemas para compilá-lo no Azure Pipelines, explore as seguintes possíveis causas e ações corretivas:

• Verifique as versões e o runtime do SDK do .NET Core no seu computador de desenvolvimento e verifique se correspondem ao agente. Você pode incluir um script de linha de comando dotnet --version no 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 computador de desenvolvimento para a versão mais recente do SDK do .NET Core.

• Talvez você esteja usando alguma lógica no IDE do Visual Studio que não está codificada no 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 do build de pipelines para ver os comandos exatos executados como parte do build. Repita os mesmos comandos na mesma ordem no seu computador de desenvolvimento para localizar o problema.

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

• Seus builds podem falhar intermitentemente durante a restauração de pacotes: o NuGet.org está tendo problemas ou há problemas de rede entre o data center do Azure e o NuGet.org. Você pode explorar se o uso do Azure Artifacts com o NuGet.org como uma fonte de upstream melhora a confiabilidade dos seus builds, pois ele 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 ser corrompida. Por exemplo, uma versão ou recurso mais recente da ferramenta NuGet fornecido com o SDK pode interromper sua compilação. Para isolar esse problema, use a tarefa Instalador de Ferramentas do .NET Core para especificar a versão do SDK do .NET Core usada no seu build.

Perguntas frequentes

P: Onde posso saber mais sobre o Azure Artifacts?

R: Gerenciamento de Pacotes no Azure Artifacts

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

R: Ferramentas da CLI do .NET Core

P: onde posso saber mais sobre como executar testes na minha solução?

R: testes de unidade em projetos do .NET Core

P: onde posso saber mais sobre o Flask?

R: tarefas de build e versão