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:

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

Nota

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

Pré-requisitos

• Uma conta do GitHub onde você pode criar um repositório. Crie um gratuitamente.
• Uma organização e um projeto do Azure DevOps. Crie um gratuitamente.
• Capacidade de executar pipelines em agentes hospedados pela Microsoft. Você pode comprar um trabalho paralelo ou solicitar um nível gratuito.

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

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

1. Num browser, aceda a dev.azure.com e inicie sessão.
2. Selecione a 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, vá para o Servidor de DevOps do Azure.
2. Selecione a 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 seu ambiente de compilação

Suas compilações são executadas em agentes hospedados pela Microsoft. Você pode criar seus projetos .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 não suportados oficialmente pelos Serviços de DevOps do Azure e executar compilações incrementais.

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.

YAML

Crie um novo pipeline e selecione sua fonte

1. Entre na sua organização do Azure DevOps e vá para o seu projeto.

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

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

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

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

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

Configure seu pipeline

1. Quando a guia Configurar for exibida, 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 para suas necessidades. Por exemplo, você pode especificar o pool de agentes ou adicionar uma tarefa para instalar um SDK .NET diferente.

Salve e execute seu pipeline

1. Quando estiver pronto, selecione Salvar e executar.

   

2. Opcionalmente, você pode editar a mensagem de confirmação.

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

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

Clássico

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

Criar pipeline

1. Vá para o seu projeto e selecione Pipelines.

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

3. Selecione Usar o editor clássico.

Selecione a sua fonte

1. Selecione a sua fonte. Para este 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 selecione Continuar.

Configure seu pipeline

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

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

2. Na guia Tarefas, selecione 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 + o trabalho do agente e selecionando outra tarefa do catálogo. Por exemplo, talvez você queira adicionar a tarefa Usar .NET Core como a primeira tarefa para instalar a versão necessária do SDK do .NET.

Salve e execute seu pipeline

1. Selecione Salvar e enfileirar na lista suspensa Salvar fila & 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 você personalizar! Leia mais para aprender algumas das maneiras comuns de personalizar seu pipeline.

Ambiente de construção

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

Por exemplo, o Ubuntu está definido aqui no arquivo YAML 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 no Azure Pipelines 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 versões de pré-lançamento. Se você precisar dessas versões do SDK em agentes hospedados pela Microsoft, instale-as 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 tempo de execução do .NET Core. Para instalar um SDK mais recente, defina performMultiLevelLookup como true no seguinte trecho:

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

Gorjeta

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

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.

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

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.

YAML

Você pode adicionar o comando restore ao seu pipeline usando o editor de pipeline YAML inserindo diretamente o seguinte trecho em seu azure-pipelines.yml arquivo ou usando o assistente de tarefas para adicionar a tarefa .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, 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 restore na lista suspensa Command .

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

5. Selecione Adicionar.

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

Clássico

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

1. Selecione Tarefas em seu pipeline e selecione o trabalho que executa suas tarefas de compilação.

2. Selecione + esta opção para adicionar uma nova tarefa a esse trabalho.

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

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

5. Selecione restaurar na lista de comandos e especifique quaisquer outras opções necessárias para esta tarefa.

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

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

Nota

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

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

YAML

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

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

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

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, execute as seguintes etapas:

1. Selecione Tarefas no seu pipeline.

2. Selecione o trabalho que executa suas tarefas de compilação.

3. Selecione + esta opção 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 Comando .

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

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

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

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

YAML

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

Use as seguintes etapas 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 Linha de Comando no catálogo de tarefas.

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

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

5. Insira o caminho para o .csproj arquivo 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, execute as seguintes etapas:

1. Selecione Tarefas no seu pipeline.

2. Selecione o trabalho que executa suas tarefas de compilação.

3. Selecione + esta opção para adicionar uma nova tarefa a esse trabalho.

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

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

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

7. Insira o caminho para o .csproj arquivo 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 fila e selecione uma opção para salvar as alterações.

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

YAML

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

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

2. Selecione .NET Core no catálogo de tarefas.

3. Selecione o comando que deseja executar.

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

5. Selecione Adicionar.

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

Clássico

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

1. Selecione Tarefas no seu pipeline.

2. Selecione o trabalho que executa suas tarefas de compilação.

3. Selecione + esta opção 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 deseja executar.

6. Configure 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 as 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 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

Para publicar a saída de sua compilação .NET em seu pipeline, execute as seguintes tarefas:

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

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

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'

Nota

A tarefa DotNetCoreCLI@2 tem uma publishWebProjects entrada definida como true por padrão. Esta tarefa publica todos os projetos da Web em seu repositório por padrão. Você pode encontrar mais ajuda e informações na tarefa de 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 ).

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

Nota

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 command entrada 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, 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:

• 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 pode levar algumas semanas para ser implantada em todos os data centers do Azure Pipelines. Você não precisa esperar que essa distribuição seja concluída. Você pode usar a tarefa Usar . NET Core para instalar a versão do SDK do .NET Core desejada em agentes hospedados pela Microsoft.

• 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