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:

• Configure seu ambiente de build com agentes hospedados pela Microsoft ou auto-hospedados.
• Restaure dependências, crie seu projeto e teste com a tarefa do .NET Core (DotNetCoreCLI@2) ou um script.
• Teste seu código e use a tarefa de cobertura de código de publicação para publicar os resultados da cobertura do código.
• Compacte e entregue a saída de compilação para:
  • seu pipeline.
  • um feed do NuGet.
  • Um .zip arquivo para implantar um aplicativo Web no Azure.

Observação

Para obter ajuda com projetos do .NET Framework, confira Criar aplicativos ASP.NET com o .NET Framework.

Pré-requisitos

• Uma conta do GitHub, na qual você pode criar um repositório. Crie um gratuitamente.
• Uma organização e um projeto do Azure DevOps. Crie um gratuitamente.
• Uma capacidade de executar pipelines em agentes hospedados pela Microsoft. Você pode comprar um trabalho paralelo ou solicitar uma camada gratuita.

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

Entre no Azure Pipelines. Depois de entrar, o navegador vai para https://dev.azure.com/my-organization-name e exibe o painel do Azure DevOps.

1. Em um navegador, acesse dev.azure.com e entre.
2. Selecione sua organização.
3. Crie um novo projeto selecionando Novo projeto ou Criar projeto se estiver criando o primeiro projeto na organização.
4. Insira um Nome de projeto.
5. Selecione a Visibilidade do seu projeto.
6. Selecione Criar.

1. Em um navegador, acesse Azure DevOps Server.
2. Selecione sua coleção.
3. Crie um novo projeto selecionando Novo projeto ou Criar projeto se estiver criando o primeiro projeto da coleção.
4. Insira um Nome de projeto.
5. Selecione a Visibilidade do seu projeto.
6. Selecione Criar.

Configurar o ambiente de compilação

Suas compilações são executadas em agentes hospedados pela Microsoft. Você pode criar seus projetos do .NET Core usando o SDK do .NET Core e o tempo de execução no Windows, Linux e macOS.

Como alternativa, você pode usar um agente auto-hospedado. Com um agente auto-hospedado, você pode usar SDKs de visualização ou privados sem suporte oficial dos Serviços de DevOps do Azure e executar compilações incrementais.

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.

YAML

Criar um novo pipeline e selecionar sua origem

1. Entre na organização do Azure DevOps e acesse seu projeto.

2. Vá para Pipelines e selecione Novo pipeline ou Criar pipeline se estiver criando seu primeiro pipeline.

3. Percorra as etapas do assistente selecionando primeiro o GitHub como o local do código-fonte.

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

5. Quando a lista de repositórios for exibida, selecione o repositório.

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

Configurar seu pipeline

1. Quando a guia Configurar aparecer, selecione Mostrar mais e selecione o modelo de pipeline ASP.NET Core na lista.

2. Examine seu novo pipeline para ver o que o YAML faz.

Você pode personalizar o arquivo YAML de acordo com seus requisitos. Por exemplo, você pode especificar o pool de agentes ou adicionar uma tarefa para instalar outro SDK do .NET.

Salvar e executar o seu pipeline

1. Ao final, selecione Salvar e executar.

   

2. Você também pode editar a mensagem de confirmação.

3. Confirme o novo arquivo azure-pipelines.yml para o seu repositório selecionando Salvar e executar.

4. Para observar seu pipeline em ação, selecione o trabalho na seção Trabalhos.

Clássico

Siga estas etapas para criar seu pipeline usando o editor clássico.

Criar um pipeline

1. Acesse seu projeto e selecione Pipelines.

2. Selecione Criar pipeline ou Novo pipeline, se não estiver criando o primeiro pipeline para esse projeto.

3. Selecione Usar o editor clássico.

Selecionar sua fonte

1. Selecione sua fonte. Neste exemplo, selecione GitHub.
2. Insira suas credenciais do GitHub para criar uma conexão de serviço do GitHub para usar em seu pipeline.
3. Selecione seu repositório e escolha Continuar.

Configurar seu pipeline

1. Em Selecionar um modelo, localize e selecione ASP.NET Core.

   A página do pipeline é aberta onde você pode configurar seu pipeline. Aqui você pode adicionar tarefas, especificar os pools de agentes e os agentes e configurar outras opções de compilação.

2. Na guia Tarefas, selecione o seu Pool de agentes (geralmente Padrão)

3. Selecione a Especificação do agente. Para este exemplo, selecione windows-latest.

   Você pode adicionar outras tarefas ao trabalho do agente selecionando + no trabalho do agente e escolhendo outra tarefa do catálogo. Por exemplo, convém adicionar a tarefa Usar o .NET Core como a primeira tarefa para instalar a versão necessária do SDK do .NET.

Salvar e executar o seu pipeline

1. Selecione Salvar e enfileirar na lista suspensa Salvar & enfileirar na parte superior da página.
2. Em Executar pipeline, insira um comentário e selecione Salvar e executar.

Você pode ver seu pipeline em ação selecionando o trabalho na seção Trabalhos, na guia Resumo.

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

Você pode usar os pipelines do Azure para criar seus projetos do .NET Core no Windows, Linux ou macOS sem a necessidade de configurar a infraestrutura.

Por exemplo, o Ubuntu é definido aqui no arquivo YAML do pipeline.

pool:
  vmImage: 'ubuntu-latest' 

Consulte Agentes hospedados pela Microsoft para obter uma lista completa de imagens e outros exemplos de configuração.

Os agentes hospedados pela Microsoft nos pipelines do Azure incluem várias versões pré-instaladas de SDKs do .NET Core com suporte. Os agentes hospedados pela Microsoft não incluem algumas das versões mais antigas do SDK do .NET Core. Eles também normalmente não incluem as versões de pré-lançamento. Se você precisar dessas versões do SDK em agentes hospedados pela Microsoft, instale-os usando a tarefa UseDotNet@2.

Por exemplo, para instalar o SDK 5.0.x, adicione o seguinte trecho:

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 performMultiLevelLookup como true no seguinte snippet:

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

Dica

Para economizar o custo de execução do instalador da ferramenta, você pode configurar um agente auto-hospedado do Linux, macOS ou Windows. Você também pode usar agentes auto-hospedados para economizar mais tempo se tiver um repositório grande ou executar compilações incrementais. Um agente auto-hospedado também pode ajudar você a usar a visualização ou SDKs privados que não são oficialmente compatíveis com o Azure DevOps ou estão disponíveis apenas em seus ambientes corporativos ou na infraestrutura local.

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.

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 mitigação, você pode usar o Azure Artifacts ou um agente auto-hospedado com o benefício de usar o cache de pacotes.

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.

YAML

Você pode adicionar o comando restore para o pipeline usando o editor de pipeline YAML inserindo diretamente o seguinte trecho no arquivo azure-pipelines.yml ou usando o assistente de tarefas para adicionar a tarefa do .NET Core.

# do this before your build tasks
steps:
- task: DotNetCoreCLI@2
  displayName: Restore
  inputs:
    command: restore
    projects: '**/*.csproj'
    feedsToUse: config
    nugetConfigPath: NuGet.config    # Relative to root of the repository
    externalFeedCredentials: <Name of the NuGet service connection>

Substitua o <espaço reservado> pelo nome da conexão de serviço.

Para usar o assistente de tarefas:

Para adicionar uma tarefa de compilação usando o assistente de tarefas, siga estas 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 restore na lista suspensa Comandos.

4. No campo Caminho para o(s) projeto(s), insira o caminho para os arquivos .csproj.

5. Selecione Adicionar.

6. Selecione Salvar para confirmar a alteração.

Clássico

Siga estas etapas para adicionar uma tarefa de restauração usando o editor clássico:

1. Selecione Tarefas no pipeline e selecione o trabalho que executa as tarefas de compilação.

2. Selecione + para adicionar uma nova tarefa a esse trabalho.

3. No catálogo de tarefas, localize e selecione a tarefa do .NET Core e selecione Adicionar.

4. Selecione a tarefa para abrir o editor de tarefas.

5. Selecione restore na lista Comandos e especifique quaisquer outras opções necessárias para essa tarefa.

6. Na lista de tarefas, arraste a tarefa para posicioná-la antes da tarefa de compilação.

7. Na lista suspensa Salvar & enfileirar, selecione uma opção para salvar a alteração.

Observação

Verifique se o feed personalizado está especificado no seu arquivo NuGet.config e se as credenciais estão especificadas na conexão de serviço do NuGet.

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

YAML

Você pode adicionar uma tarefa de compilação usando o editor de pipeline YAML editando diretamente o arquivo ou adicionando a tarefa do .NET Core com o assistente de tarefas.

Para adicionar uma tarefa de compilação usando o assistente de tarefas, siga estas 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 build na lista suspensa Comandos.

4. No campo Caminho para o(s) projeto(s), insira o caminho para os arquivos .csproj.

5. Selecione Adicionar.

6. Selecione Salvar para confirmar a alteração.

Clássico

Para adicionar uma tarefa de compilação usando o editor clássico, siga estas etapas:

1. Selecione Tarefas em seu pipeline.

2. Selecione o trabalho que executa suas tarefas de build.

3. Selecione + para adicionar uma nova tarefa a esse trabalho.

4. No catálogo de tarefas, localize e adicione a tarefa .NET Core.

5. Selecione a tarefa e selecione build na lista suspensa Comandos.

6. No campo Caminho para o(s) projeto(s), insira o caminho para os arquivos .csproj.

7. Arraste a tarefa para posicioná-la na sequência de tarefas correta no pipeline.

8. Selecione a lista suspensa Salvar e enfileirar e selecione uma opção para salvar suas alterações.

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

YAML

Você pode adicionar uma tarefa de compilação usando o editor de pipeline YAML editando diretamente o arquivo ou adicionando a tarefa da Linha de comando.

Siga estas etapas para adicionar a tarefa da Linha de comando:

1. Vá para a posição no arquivo YAML onde você deseja inserir a tarefa.

2. Selecione a Linha de comando no catálogo de tarefas.

3. Opcionalmente, adicione um Nome de exibição.

4. Insira o comando dotnet build com parâmetros. Por exemplo, dotnet build --configuration $(buildConfiguration).

5. Insira o caminho para o arquivo .csproj como o diretório de trabalho.

6. Selecione Adicionar.

7. Selecione Salvar para confirmar a alteração.

Clássico

Para adicionar uma tarefa de compilação usando o editor clássico, siga estas etapas:

1. Selecione Tarefas em seu pipeline.

2. Selecione o trabalho que executa suas tarefas de build.

3. Selecione + para adicionar uma nova tarefa a esse trabalho.

4. No catálogo de tarefas, localize e adicione a tarefa da Linha de comando.

5. Opcionalmente, adicione um Nome de exibição.

6. Insira o comando dotnet build com parâmetros. Por exemplo, dotnet build --configuration $(buildConfiguration).

7. Insira o caminho para o arquivo .csproj como o diretório de trabalho.

8. Arraste a tarefa para posicioná-la na sequência de tarefas correta no pipeline.

9. Selecione a lista suspensa Salvar e enfileirar e selecione uma opção para salvar suas alterações.

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

YAML

Para adicionar um comando da CLI do .NET Core usando o editor de pipeline YAML, siga estas 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.

4. Configure todas as opções necessárias.

5. Selecione Adicionar.

6. Selecione Salvar para confirmar a alteração.

Clássico

Para adicionar a tarefa do .NET Core usando o editor clássico, siga estas etapas:

1. Selecione Tarefas em seu pipeline.

2. Selecione o trabalho que executa suas tarefas de build.

3. Selecione + para adicionar uma nova tarefa a esse trabalho.

4. No catálogo de tarefas, localize e adicione a tarefa .NET Core.

5. Selecione a tarefa e selecione o comando que você deseja executar.

6. Configure todas as opções necessárias.

7. Arraste a tarefa para posicioná-la na sequência de tarefas correta no pipeline.

8. Na lista suspensa Salvar e enfileirar, selecione uma opção para salvar suas alterações.

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

Para publicar a saída da compilação no pipeline, siga estas tarefas:

• Execute dotnet publish --output $(Build.ArtifactStagingDirectory) na CLI do .NET ou adicione a tarefa DotNetCoreCLI@2 com o comando publish.
• Publique o artefato usando a tarefa Publicar Artefatos de Pipeline.

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

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'

Observação

A tarefa DotNetCoreCLI@2 tem uma entrada publishWebProjects definida como true por padrão. Essa tarefa publica todos os projetos Web no seu repositório por padrão. Você pode encontrar mais ajuda e informações na tarefa Código aberto no GitHub.

Para copiar mais arquivos para o diretório de compilação antes de publicar, use a tarefa Copiar arquivos (CopyFile@2).

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

Observação

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

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:

• As versões de pré-lançamento do SDK do .NET Core não são instaladas em agentes hospedados pela Microsoft. Depois que uma nova versão do SDK do .NET Core for lançada, ela poderá levar algumas semanas para ser implementada em todos os data centers dos pipelines do Azure. Não é necessário aguardar a conclusão dessa distribuição. Você pode usar a tarefa do Use .NET Core para instalar a versão do SDK do .NET Core desejada nos agentes hospedados pela Microsoft.

• 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