Criar, testar e implementar aplicações .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 .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 o seu código e use a tarefa Publicar Cobertura de Código para publicar os resultados de cobertura de código.
• Empacote e entregue sua saída de compilação para:
  • your pipeline.
  • a NuGet feed.
  • 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

Produto	Requisitos
Azure DevOps	- An Azure DevOps organization and project. Crie um gratuitamente. - Permissões:     - Para conceder acesso a todos os pipelines no projeto: Você deve ser membro do grupo Administradores de Projeto.     - To create service connections: You must have the Administrator or Creator role for service connections. - Capacidade de executar pipelines em agentes hospedados pela Microsoft. Você pode comprar um trabalho paralelo ou solicitar um nível gratuito.
GitHub	- Uma conta GitHub.

Create your first 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. Start by installing the .NET 8.0 SDK .

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. Once the application starts, press Ctrl-C to shut it down.

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

1. From the project directory, create a local git repository and commit the application code to the main branch.

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

Criar um projeto de DevOps

Create a new Azure DevOps project to host your pipeline.

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.

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, podes usar um agente autogerido. 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.

Create your 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, primeiro selecionando GitHub como o local do seu código-fonte.

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

5. When you see the list of repositories, select your repository.

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

Configure your pipeline

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

2. Examine your new pipeline to see what the YAML does.

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.

Save and run your 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. To watch your pipeline in action, select the job in the Jobs section.

Clássico

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

Criar canalização

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 your pipeline

1. From Select a template, find then select ASP.NET Core.

   A página do pipeline abre-se, onde o utilizador pode configurar o 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.

Save and run your pipeline

1. Select Save and queue from the Save & queue dropdown list at the top of the page.
2. Em Executar pipeline, insira um comentário e selecione Salvar e Executar.

You can see your pipeline in action by selecting the job from the Jobs section on the Summary tab.

You now have a working pipeline that's ready for you to customize! Leia mais para aprender algumas das maneiras comuns de personalizar seu pipeline.

Build environment

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

For example, Ubuntu is set here in the pipeline YAML file.

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 ambiente de execução .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

Tip

Para economizar o custo de execução do instalador da ferramenta, você pode configurar um agente auto-hospedado Linux, macOS ou Windows. You can also use self-hosted agents to save time if you have a large repository or you run incremental builds. A self-hosted agent can also help you in using the SDKs that aren't included in Azure DevOps or are only available on your corporate or on-premises environments.

Restore dependencies

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. If your feed is in the same project as your pipeline, you don't need to authenticate.

This pipeline uses an Azure Artifact feed for dotnet restore in the DotNetCoreCLI@2 task.

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'

Nota

Se você estiver usando o Ubuntu 24.04 ou superior, você deve usar a tarefa NuGetAuthenticate com a CLI do .NET em vez da tarefa NuGetCommand@2. For more information, see Support for newer Ubuntu hosted images.

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.

As suas compilações podem falhar devido a problemas de conexão ao restaurar pacotes do NuGet.org. Pode usar o Azure Artifacts com fontes upstream para armazenar em cache os pacotes. 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 mitigar, pode usar Azure Artifacts ou um agente auto-hospedado, tirando proveito do cache de pacotes.

For more information about NuGet service connections, see publish to NuGet feeds.

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>

Replace the <placeholder> with your service connection name.

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. Select the restore command from the Command dropdown list.

4. No campo Caminho para projeto(s), indique o caminho para os seus .csproj ficheiros.

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 + para adicionar uma nova tarefa a essa tarefa.

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. From the Save & queue dropdown list, select an option to save the change.

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.

Build with the .NET Core task

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. Select the build command from the Command dropdown list.

4. No campo Caminho para projeto(s), indique o caminho para os seus .csproj ficheiros.

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 fluxo de trabalho.

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

3. Selecione + para adicionar uma nova tarefa a essa tarefa.

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

5. Select the task and select build from the Command dropdown list.

6. No campo Caminho para projeto(s), indique o caminho para os seus .csproj ficheiros.

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

8. Select the Save and queue dropdown list and select an option to save your changes.

Build .NET Core with a command line script

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

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

YAML

You can add a build task using the YAML pipeline editor by directly editing the file or adding the Command Line task.

Use as seguintes etapas para adicionar a tarefa de linha de comandos:

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 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 fluxo de trabalho.

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

3. Selecione + para adicionar uma nova tarefa a essa tarefa.

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

5. Opcionalmente, adicione um Nome de 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 fluxo de trabalho.

9. Select the Save and queue dropdown list and select an option to save your changes.

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.

Add a .NET CLI command with the .NET Core task

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 any options needed.

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 fluxo de trabalho.

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

3. Selecione + para adicionar uma nova tarefa a essa tarefa.

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 any options needed.

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

8. From the Save and queue dropdown list, select an option to save your changes.

Add a .NET Core CLI command in a 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.
     • Path to projects: leave empty.
   • Ferramenta de comando personalizado.
   • Argumentos: install -g dotnetsay.
2. Para executar a ferramenta, adicione uma linha de comando e defina as seguintes propriedades:
   • Script: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, pode-se executar o comando dotnet test com um registrador específico e, em seguida, usar a tarefa Publicar resultados de 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'

Collect code coverage

When you're building on the Windows platform, code coverage metrics can be collected by using the built-in coverage data collector. 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 referir-se 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 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'

Collect code coverage metrics with 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.

You can publish code coverage results to the server with the Publish Code Coverage Results task (PublishCodeCoverageResults@2) task. The coverage tool must be configured to generate results in Cobertura or JaCoCo coverage format.

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@2
    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:

• Publishing to Azure Pipelines.
• Publicando pacotes no Azure Artifacts.
• Creating a NuGet package and publish to your NuGet feed.
• Criar um arquivo .zip para implantar seu aplicativo Web.

Publicar artefatos no Azure Pipelines

To publish the output of your .NET build to your pipeline, do the following tasks:

• Execute dotnet publish --output $(Build.ArtifactStagingDirectory) na CLI do .NET ou adicione a tarefa DotNetCoreCLI@2 com o comando de publicação.
• Publish the artifact by using the Publish Pipeline Artifact task.

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. If you're using a NuGet API key, use the NuGetCommand@2 task with the command input set to push with the --api-key argument. 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 os seus pacotes NuGet no seu feed de Artefatos do Azure usando o NuGetCommand@2 para enviar ao 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 para o registo de contentores

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'

When using the classic editor, select Index sources publish symbols from the task catalog to add to your pipeline.

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

Troubleshoot

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. To locate the problem, repeat the same commands in the same order on your development machine.

• 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?

A: 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 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