Adicionar estágios, dependências, & condições

Azure DevOps Services | Azure DevOps Server 2022 – Azure DevOps Server 2019 | TFS 2018

Observação

Em Microsoft Team Foundation Server (TFS) 2018 e versões anteriores, pipelines de build e versão são chamados de definições, execuções são chamadas de builds, conexões de serviço são chamadas de pontos de extremidade de serviço, estágios são chamados de ambientes e trabalhos são chamados de fases.

O conceito de fases varia dependendo se você usa pipelines do YAML ou pipelines de lançamento clássicos.

Você pode organizar os trabalhos do pipeline em fases. As fases são as principais divisões em um pipeline: "criar este aplicativo", "executar esses testes" e "implantar na pré-produção" são bons exemplos de fases. São limites lógicos no pipeline em que se pode pausar o pipeline e executar várias verificações.

Cada pipeline tem pelo menos um estágio, mesmo que você não o defina explicitamente. Você também pode organizar estágios em um grafo de dependência para que um estágio seja executado antes de outro. Há um limite de 256 trabalhos para uma fase.

Observação

O suporte para estágios foi adicionado no Azure DevOps Server 2019.1.

Esta versão do TFS não dá suporte ao YAML.

Especificar estágios

Observação

O suporte para estágios foi adicionado no Azure DevOps Server 2019.1.

No caso mais simples, você não precisa de limites lógicos em seu pipeline. Nesse caso, você não precisa usar explicitamente a stage palavra-chave. Você pode especificar diretamente os trabalhos em seu arquivo YAML.

# this has one implicit stage and one implicit job
pool:
  vmImage: 'ubuntu-latest'
steps:
- bash: echo "Hello world"
# this pipeline has one implicit stage
jobs:
- job: A
  steps:
  - bash: echo "A"

- job: B
  steps:
  - bash: echo "B"

Se você organizar seu pipeline em vários estágios, use a stages palavra-chave.

stages:
- stage: A
  jobs:
  - job: A1
  - job: A2

- stage: B
  jobs:
  - job: B1
  - job: B2

Se você optar por especificar um pool no nível do estágio, todos os trabalhos definidos nessa fase usarão esse pool, a menos que especificado de outra forma no nível do trabalho.

Observação

No Azure DevOps Server 2019, os pools só podem ser especificados no nível do trabalho.

stages:
- stage: A
  pool: StageAPool
  jobs:
  - job: A1 # will run on "StageAPool" pool based on the pool defined on the stage
  - job: A2 # will run on "JobPool" pool
    pool: JobPool

A sintaxe completa para especificar um estágio é:

stages:
- stage: string  # name of the stage, A-Z, a-z, 0-9, and underscore
  displayName: string  # friendly name to display in the UI
  dependsOn: string | [ string ]
  condition: string
  pool: string | pool
  variables: { string: string } | [ variable | variableReference ] 
  jobs: [ job | templateReference]

Esta versão do TFS não dá suporte a pipelines YAML.

Especificar dependências

Observação

O suporte para estágios foi adicionado no Azure DevOps Server 2019.1.

Quando você define vários estágios em um pipeline, por padrão, eles são executados sequencialmente na ordem em que você os define no arquivo YAML. A exceção a isso é quando você adiciona dependências. Com dependências, os estágios são executados na ordem dos dependsOn requisitos.

Os pipelines devem conter pelo menos um estágio sem dependências.

A sintaxe para definir vários estágios e suas dependências é:

stages:
- stage: string
  dependsOn: string
  condition: string

Exemplo de estágios que são executados sequencialmente:

# if you do not use a dependsOn keyword, stages run in the order they are defined
stages:
- stage: QA
  jobs:
  - job:
    ...

- stage: Prod
  jobs:
  - job:
    ...

Exemplo de estágios que são executados em paralelo:

stages:
- stage: FunctionalTest
  jobs:
  - job:
    ...

- stage: AcceptanceTest
  dependsOn: []    # this removes the implicit dependency on previous stage and causes this to run in parallel
  jobs:
  - job:
    ...

Exemplo de fan-out e fan-in:

stages:
- stage: Test

- stage: DeployUS1
  dependsOn: Test    # this stage runs after Test

- stage: DeployUS2
  dependsOn: Test    # this stage runs in parallel with DeployUS1, after Test

- stage: DeployEurope
  dependsOn:         # this stage runs after DeployUS1 and DeployUS2
  - DeployUS1
  - DeployUS2

Esta versão do TFS não dá suporte a pipelines YAML.

Condições

Você pode especificar as condições sob as quais cada estágio é executado. Por padrão, um estágio será executado se ele não depender de nenhum outro estágio ou se todos os estágios dos quais depende tiverem sido concluídos e tiverem êxito. Você pode personalizar esse comportamento forçando um estágio a ser executado mesmo se um estágio anterior falhar ou especificando uma condição personalizada.

Se você personalizar a condição padrão das etapas anteriores para um estágio, remova as condições de conclusão e êxito. Portanto, se você usar uma condição personalizada, é comum usar and(succeeded(),custom_condition) para verificar se o estágio anterior foi executado com êxito. Caso contrário, o estágio será executado independentemente do resultado da fase anterior.

Observação

As condições para falha ('JOBNAME/STAGENAME') e êxito ('JOBNAME/STAGENAME') conforme mostrado no exemplo a seguir funcionam apenas para pipelines YAML.

Observação

O suporte para estágios foi adicionado no Azure DevOps Server 2019.1.

Exemplo para executar um estágio com base no status de execução de um estágio anterior:

stages:
- stage: A

# stage B runs if A fails
- stage: B
  condition: failed()

# stage C runs if B succeeds
- stage: C
  dependsOn:
  - A
  - B
  condition: succeeded('B')

Exemplo de uso de uma condição personalizada:

stages:
- stage: A

- stage: B
  condition: and(succeeded(), eq(variables['build.sourceBranch'], 'refs/heads/main'))

Esta versão do TFS não dá suporte a pipelines YAML.

Especificar políticas de enfileiramento

Pipelines YAML não dão suporte a políticas de enfileiramento. Cada execução de um pipeline é independente e desconhece outras execuções. Em outras palavras, suas duas confirmações sucessivas podem disparar dois pipelines, e ambos executarão a mesma sequência de estágios sem esperar um pelo outro. Embora trabalhemos para trazer políticas de enfileiramento para pipelines YAML, recomendamos que você use aprovações manuais para sequenciar manualmente e controlar a ordem de execução se isso for importante.

Esta versão do TFS não dá suporte a pipelines YAML.

Especificar aprovações

Você pode controlar manualmente quando um estágio deve ser executado usando verificações de aprovação. Isso geralmente é usado para controlar implantações em ambientes de produção. Verificações são um mecanismo disponível para o proprietário do recurso controlar se e quando um estágio em um pipeline pode consumir um recurso. Como proprietário de um recurso, como um ambiente, você pode definir verificações que devem ser atendidas antes que um estágio que consuma esse recurso possa começar.

Atualmente, há suporte para verificações de aprovação manuais em ambientes. Para obter mais informações, consulte Aprovações.

Ainda não há suporte para aprovações em pipelines YAML nesta versão do Azure DevOps Server.

Esta versão do TFS não dá suporte a pipelines YAML.