Tutorial: Criar um pipeline de vários estágios com o Azure DevOps

2025-10-08

Serviços de DevOps do Azure | Azure DevOps Server | Azure DevOps Server 2022 | Azure DevOps Server 2020

Use um pipeline de vários estágios do Azure DevOps para dividir seu processo de CI/CD em estágios que representam diferentes partes do seu ciclo de desenvolvimento. Um pipeline de vários estágios dá mais visibilidade ao seu processo de implantação e facilita a integração de aprovações e verificações.

Neste artigo, você criará duas instâncias do Serviço de Aplicativo e criará um pipeline YAML com três estágios:

Build: Construa o código-fonte e produza um pacote
Dev: Implante seu pacote em um site de desenvolvimento para teste
Preparo: implantar em uma instância do Serviço de Aplicativo do Azure em preparo com uma verificação de aprovação manual

Em um cenário do mundo real, você pode ter outro estágio para implantação na produção, dependendo do seu processo de DevOps.

O código de exemplo neste exercício é para um aplicativo Web .NET para um jogo espacial simulado que inclui uma tabela de classificação para mostrar pontuações altas. Você implantará tanto nas instâncias de desenvolvimento como nas de teste da Aplicação Web do Azure para Linux.

Pré-requisitos

Produto	Requisitos
Azure DevOps	- Uma organização e um projeto de DevOps do Azure. Crie um gratuitamente. - Permissões: - Para conceder acesso a todos os pipelines no projeto: Você deve ser membro do grupo Administradores de Projeto. - Para criar conexões de serviço: Você deve ter a função de Administrador ou Criador para conexões de serviço. - 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.

Produto

Requisitos

Azure DevOps

- Uma organização e um projeto de DevOps do Azure. Crie um gratuitamente.
- Permissões:
- Para conceder acesso a todos os pipelines no projeto: Você deve ser membro do grupo Administradores de Projeto.
- Para criar conexões de serviço: Você deve ter a função de Administrador ou Criador para conexões de serviço.
- 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.

Fazer um fork do projeto

Fork o seguinte repositório de exemplo no GitHub.

https://github.com/MicrosoftDocs/mslearn-tailspin-spacegame-web-deploy

Criar as instâncias do App Service

Antes de implantar o seu pipeline, você precisa primeiro criar uma instância do App Service para implantar. Você usará a CLI do Azure para criar a instância.

Inicie sessão no portal do Azure.
No menu, selecione Cloud Shell e o ambiente Bash.
Gere um número aleatório que torne o nome de domínio do seu aplicativo Web exclusivo. A vantagem de ter um valor exclusivo é que sua instância do Serviço de Aplicativo não terá um conflito de nome com outros alunos que concluírem este tutorial.
```
webappsuffix=$RANDOM    
```
Abra um prompt de comando e use um az group create comando para criar um grupo de recursos chamado tailspin-space-game-rg que contém todas as suas instâncias do Serviço de Aplicativo. Atualize o valor ___location para usar a região mais próxima.
```
az group create --___location eastus --name tailspin-space-game-rg
```

Use o prompt de comando para criar um plano do Serviço de Aplicativo.

az appservice plan create \
  --name tailspin-space-game-asp \
  --resource-group tailspin-space-game-rg \
  --sku B1 \
  --is-linux

No prompt de comando, crie duas instâncias do Serviço de Aplicativo, uma para cada instância (Dev e Staging) com o az webapp create comando.

az webapp create \
  --name tailspin-space-game-web-dev-$webappsuffix \
  --resource-group tailspin-space-game-rg \
  --plan tailspin-space-game-asp \
  --runtime "DOTNET|8.0"

az webapp create \
  --name tailspin-space-game-web-staging-$webappsuffix \
  --resource-group tailspin-space-game-rg \
  --plan tailspin-space-game-asp \
  --runtime "DOTNET|8.0"

Com o prompt de comando, liste ambas as instâncias do App Service para verificar se elas estão a correr com o comando az webapp list.

az webapp list \
  --resource-group tailspin-space-game-rg \
  --query "[].{hostName: defaultHostName, state: state}" \
  --output table

Copie os nomes das instâncias do Serviço de Aplicativo para usar como variáveis na próxima seção.

Crie seu projeto e variáveis do Azure DevOps

Configure seu projeto do Azure DevOps e um pipeline de compilação. Você também adicionará variáveis para as suas instâncias de desenvolvimento e de teste.

O seu pipeline de build:

Inclui um gatilho que é executado quando há uma alteração de código numa ramificação
Define duas variáveis buildConfiguration e releaseBranchName
Inclui um estágio chamado Build que cria o aplicativo Web
Publica um artefato que você usará em um estágio posterior

Adicionar o estágio de Construção

Em seu projeto do Azure DevOps, selecione Pipelines no menu de navegação esquerdo.
Selecione Novo pipeline ou Criar pipeline se esse pipeline for o primeiro do projeto.
Na tela Onde está seu código , selecione GitHub.
Poderá ser redirecionado para o GitHub para iniciar sessão. Em caso afirmativo, insira suas credenciais do GitHub.
Na tela Selecione um repositório , selecione o repositório em que seu aplicativo .NET está.
Você pode ser redirecionado para o GitHub para instalar o aplicativo Azure Pipelines. Em caso afirmativo, selecione Aprovar e instalar.

Quando a guia Configurar aparecer, selecione pipeline inicial.

Substitua o conteúdo do azure-pipelines.yml por este código.

trigger:
- '*'

variables:
  buildConfiguration: 'Release'
  releaseBranchName: 'release'

stages:
- stage: 'Build'
  displayName: 'Build the web application'
  jobs: 
  - job: 'Build'
    displayName: 'Build job'
    pool:
      vmImage: 'ubuntu-22.04'
      demands:
      - npm

    variables:
      wwwrootDir: 'Tailspin.SpaceGame.Web/wwwroot'
      dotnetSdkVersion: '8.x'

    steps:
    - task: UseDotNet@2
      displayName: 'Use .NET SDK $(dotnetSdkVersion)'
      inputs:
        version: '$(dotnetSdkVersion)'

    - task: Npm@1
      displayName: 'Run npm install'
      inputs:
        verbose: false

    - script: './node_modules/.bin/node-sass $(wwwrootDir) --output $(wwwrootDir)'
      displayName: 'Compile Sass assets'

    - task: gulp@1
      displayName: 'Run gulp tasks'

    - script: 'echo "$(Build.DefinitionName), $(Build.BuildId), $(Build.BuildNumber)" > buildinfo.txt'
      displayName: 'Write build info'
      workingDirectory: $(wwwrootDir)

    - task: DotNetCoreCLI@2
      displayName: 'Restore project dependencies'
      inputs:
        command: 'restore'
        projects: '**/*.csproj'

    - task: DotNetCoreCLI@2
      displayName: 'Build the project - $(buildConfiguration)'
      inputs:
        command: 'build'
        arguments: '--no-restore --configuration $(buildConfiguration)'
        projects: '**/*.csproj'

    - task: DotNetCoreCLI@2
      displayName: 'Publish the project - $(buildConfiguration)'
      inputs:
        command: 'publish'
        projects: '**/*.csproj'
        publishWebProjects: false
        arguments: '--no-build --configuration $(buildConfiguration) --output $(Build.ArtifactStagingDirectory)/$(buildConfiguration)'
        zipAfterPublish: true

    - publish: '$(Build.ArtifactStagingDirectory)'
      artifact: drop

Quando estiver pronto, selecione Salvar e executar.

Adicionar variáveis de instância

No Azure DevOps, vá para Pipelines>Biblioteca.
Selecione + Grupo de variáveis.
Em Propriedades, adicione Release para o nome do grupo de variáveis.
Crie duas variáveis para fazer referência aos seus nomes de host de desenvolvimento e testes. Substitua o valor 1234 pelo valor correto para sua instância.

Nome da variável Valor de exemplo

WebAppNameDev tailspin-espaço-jogo-web-dev-1234

WebAppNameStaging tailspin-espaço-jogo-web-encenação-1234
Selecione Salvar para salvar suas variáveis.

Nome da variável	Valor de exemplo
WebAppNameDev	tailspin-espaço-jogo-web-dev-1234
WebAppNameStaging	tailspin-espaço-jogo-web-encenação-1234

Adicionar o estágio de desenvolvimento

Em seguida, você atualizará seu pipeline para promover sua compilação para o estágio de desenvolvimento .

No Azure Pipelines, vá para Pipelines>Pipelines.
Selecione Editar no menu contextual para editar seu pipeline.

Atualize azure-pipelines.yml para incluir um estágio de desenvolvimento. No estágio de desenvolvimento, o seu pipeline irá:

Executar quando o estágio de Build for bem-sucedido por causa de uma condição
Baixar um artefato de drop
Implantar no Serviço de Aplicações do Azure com uma ligação de serviço do Azure Resource Manager

trigger:
- '*'

variables:
  buildConfiguration: 'Release'
  releaseBranchName: 'release'

stages:
- stage: 'Build'
  displayName: 'Build the web application'
  jobs: 
  - job: 'Build'
    displayName: 'Build job'
    pool:
      vmImage: 'ubuntu-22.04'
      demands:
      - npm

    variables:
      wwwrootDir: 'Tailspin.SpaceGame.Web/wwwroot'
      dotnetSdkVersion: '8.x'

    steps:
    - task: UseDotNet@2
      displayName: 'Use .NET SDK $(dotnetSdkVersion)'
      inputs:
        version: '$(dotnetSdkVersion)'

    - task: Npm@1
      displayName: 'Run npm install'
      inputs:
        verbose: false

    - script: './node_modules/.bin/node-sass $(wwwrootDir) --output $(wwwrootDir)'
      displayName: 'Compile Sass assets'

    - task: gulp@1
      displayName: 'Run gulp tasks'

    - script: 'echo "$(Build.DefinitionName), $(Build.BuildId), $(Build.BuildNumber)" > buildinfo.txt'
      displayName: 'Write build info'
      workingDirectory: $(wwwrootDir)

    - task: DotNetCoreCLI@2
      displayName: 'Restore project dependencies'
      inputs:
        command: 'restore'
        projects: '**/*.csproj'

    - task: DotNetCoreCLI@2
      displayName: 'Build the project - $(buildConfiguration)'
      inputs:
        command: 'build'
        arguments: '--no-restore --configuration $(buildConfiguration)'
        projects: '**/*.csproj'

    - task: DotNetCoreCLI@2
      displayName: 'Publish the project - $(buildConfiguration)'
      inputs:
        command: 'publish'
        projects: '**/*.csproj'
        publishWebProjects: false
        arguments: '--no-build --configuration $(buildConfiguration) --output $(Build.ArtifactStagingDirectory)/$(buildConfiguration)'
        zipAfterPublish: true

    - publish: '$(Build.ArtifactStagingDirectory)'
      artifact: drop

- stage: 'Dev'
  displayName: 'Deploy to the dev environment'
  dependsOn: Build
  condition:  succeeded()
  jobs:
  - deployment: Deploy
    pool:
      vmImage: 'ubuntu-22.04'
    environment: dev
    variables:
    - group: Release
    strategy:
      runOnce:
        deploy:
          steps:
          - download: current
            artifact: drop
          - task: AzureWebApp@1
            displayName: 'Azure App Service Deploy: dev website'
            inputs:
              azureSubscription: 'your-subscription'
              appType: 'webAppLinux'
              appName: '$(WebAppNameDev)'
              package: '$(Pipeline.Workspace)/drop/$(buildConfiguration)/*.zip'

Altere a tarefa AzureWebApp@1 para utilizar a sua subscrição.
1. Selecione Configurações para a tarefa.
2. Atualize o your-subscription valor da Subscrição do Azure para utilizar sua própria subscrição. Poderá ter de autorizar o acesso como parte deste processo. Se você tiver um problema ao autorizar seu recurso no editor YAML, uma abordagem alternativa é criar uma conexão de serviço.
3. Defina o tipo de aplicativo como Aplicativo Web no Linux.
4. Selecione Adicionar para atualizar a tarefa.
Guarde e execute o seu pipeline.

Adicionar o estágio de preparo

Por último, você promoverá o estágio de desenvolvimento para Staging. Ao contrário do ambiente de desenvolvimento, você deseja ter mais controle no ambiente de preparo e adicionará uma aprovação manual.

Criar ambiente de preparo

Em Azure Pipelines, selecione Environments.
Selecione Novo ambiente.
Crie um novo ambiente com o nome preparo e Recurso definido como Nenhum.
Na página Ambiente de preparação, selecione Aprovações e verificações.
Selecione Aprovações.
Em Aprovadores, selecione Adicionar utilizadores e grupos e, em seguida, selecione a sua conta.
Em Instruções para aprovadores, escreva Aprovar esta alteração quando estiver pronto para aprovação.
Selecione Guardar.

Adicionar novo estágio ao pipeline

Você adicionará um novo estágio Staging ao pipeline que inclui uma aprovação manual.

Edite seu arquivo de pipeline e adicione a Staging seção.

trigger:
- '*'

variables:
  buildConfiguration: 'Release'
  releaseBranchName: 'release'

stages:
- stage: 'Build'
  displayName: 'Build the web application'
  jobs: 
  - job: 'Build'
    displayName: 'Build job'
    pool:
      vmImage: 'ubuntu-22.04'
      demands:
      - npm

    variables:
      wwwrootDir: 'Tailspin.SpaceGame.Web/wwwroot'
      dotnetSdkVersion: '8.x'

    steps:
    - task: UseDotNet@2
      displayName: 'Use .NET SDK $(dotnetSdkVersion)'
      inputs:
        version: '$(dotnetSdkVersion)'

    - task: Npm@1
      displayName: 'Run npm install'
      inputs:
        verbose: false

    - script: './node_modules/.bin/node-sass $(wwwrootDir) --output $(wwwrootDir)'
      displayName: 'Compile Sass assets'

    - task: gulp@1
      displayName: 'Run gulp tasks'

    - script: 'echo "$(Build.DefinitionName), $(Build.BuildId), $(Build.BuildNumber)" > buildinfo.txt'
      displayName: 'Write build info'
      workingDirectory: $(wwwrootDir)

    - task: DotNetCoreCLI@2
      displayName: 'Restore project dependencies'
      inputs:
        command: 'restore'
        projects: '**/*.csproj'

    - task: DotNetCoreCLI@2
      displayName: 'Build the project - $(buildConfiguration)'
      inputs:
        command: 'build'
        arguments: '--no-restore --configuration $(buildConfiguration)'
        projects: '**/*.csproj'

    - task: DotNetCoreCLI@2
      displayName: 'Publish the project - $(buildConfiguration)'
      inputs:
        command: 'publish'
        projects: '**/*.csproj'
        publishWebProjects: false
        arguments: '--no-build --configuration $(buildConfiguration) --output $(Build.ArtifactStagingDirectory)/$(buildConfiguration)'
        zipAfterPublish: true

    - publish: '$(Build.ArtifactStagingDirectory)'
      artifact: drop

- stage: 'Dev'
  displayName: 'Deploy to the dev environment'
  dependsOn: Build
  condition:  succeeded()
  jobs:
  - deployment: Deploy
    pool:
      vmImage: 'ubuntu-22.04'
    environment: dev
    variables:
    - group: Release
    strategy:
      runOnce:
        deploy:
          steps:
          - download: current
            artifact: drop
          - task: AzureWebApp@1
            displayName: 'Azure App Service Deploy: dev website'
            inputs:
              azureSubscription: 'your-subscription'
              appType: 'webAppLinux'
              appName: '$(WebAppNameDev)'
              package: '$(Pipeline.Workspace)/drop/$(buildConfiguration)/*.zip'

- stage: 'Staging'
  displayName: 'Deploy to the staging environment'
  dependsOn: Dev
  jobs:
  - deployment: Deploy
    pool:
      vmImage: 'ubuntu-22.04'
    environment: staging
    variables:
    - group: 'Release'
    strategy:
      runOnce:
        deploy:
          steps:
          - download: current
            artifact: drop
          - task: AzureWebApp@1
            displayName: 'Azure App Service Deploy: staging website'
            inputs:
              azureSubscription: 'your-subscription'
              appType: 'webAppLinux'
              appName: '$(WebAppNameStaging)'
              package: '$(Pipeline.Workspace)/drop/$(buildConfiguration)/*.zip'

Altere a tarefa na fase de Staging AzureWebApp@1 para usar a sua assinatura.
1. Selecione Configurações para a tarefa.
2. Atualize o your-subscription valor da Subscrição do Azure para utilizar sua própria subscrição. Poderá ter de autorizar o acesso como parte deste processo.
3. Defina o tipo de aplicativo como Aplicativo Web no Linux.
4. Selecione Adicionar para atualizar a tarefa.
Vá para a execução da linha de produção. Observe a compilação enquanto ela é executada. Quando chega Staging, o pipeline aguarda a aprovação manual do lançamento. Você também receberá um e-mail informando que tem um pipeline pendente de aprovação.
Revise a aprovação e permita a execução do pipeline.

Limpar recursos

Se você não vai continuar a usar esse aplicativo, exclua o grupo de recursos no portal do Azure e o projeto no Azure DevOps com as seguintes etapas:

Para limpar o seu grupo de recursos:

Aceda ao Portal do Azure e inicie sessão.
Na barra de menus, selecione Cloud Shell. Quando solicitado, selecione a experiência Bash .
Execute o seguinte comando az group delete para excluir o grupo de recursos que você usou, tailspin-space-game-rg.
```
az group delete --name tailspin-space-game-rg
```

Para excluir seu projeto de DevOps do Azure, incluindo o pipeline de compilação, consulte Excluir projeto.

Comentários

Esta página foi útil?