Expressões

Azure DevOps Services | Azure DevOps Server | 2020 Azure DevOps Server | 2019 TFS 2018

Nota

No Microsoft Team Foundation Server (TFS) 2018 e nas versões anteriores, os oleodutos de construção e libertação são chamados definições, as corridas são chamadas de construções, as ligações de serviço são chamadas pontos finais de serviço, as fases são chamadas de ambientes, e os empregos são chamados de fases.

Expressões podem ser usadas em muitos lugares onde você precisa especificar um string, boolean, ou valor de número ao autorizar um pipeline. O uso mais comum de expressões está em condições para determinar se um trabalho ou passo deve ser executado.

# Expressions are used to define conditions for a step, job, or stage
steps:
- task: ...
  condition: <expression>

Outro uso comum de expressões é na definição de variáveis. As expressões podem ser avaliadas no momento da compilação ou no tempo de execução. As expressões de tempo de compilação podem ser usadas em qualquer lugar; expressões de tempo de execução podem ser usadas em variáveis e condições. As expressões de tempo de execução destinam-se a calcular o conteúdo das variáveis e do estado (exemplo: condition).

# Two examples of expressions used to define variables
# The first one, a, is evaluated when the YAML file is compiled into a plan.
# The second one, b, is evaluated at runtime.
# Note the syntax ${{}} for compile time and $[] for runtime expressions.
variables:
  a: ${{ <expression> }}
  b: $[ <expression> ]

A diferença entre o tempo de execução e as sintaxes de expressão temporal compilam-se principalmente em que contexto está disponível. Numa expressão de tempo de compilação (${{ <expression> }}), você tem acesso parameters e estáticamente definido variables. Numa expressão de tempo de execução ($[ <expression> ]), você tem acesso a mais variables , mas sem parâmetros.

Neste exemplo, uma expressão de tempo de execução define o valor de $(isMain). Uma variável estática numa expressão compila define o valor de $(compileVar).

variables:
  staticVar: 'my value' # static variable
  compileVar: ${{ variables.staticVar }} # compile time expression
  isMain: $[eq(variables['Build.SourceBranch'], 'refs/heads/main')] # runtime expression

steps:
  - script: |
      echo ${{variables.staticVar}} # outputs my value
      echo $(compileVar) # outputs my value
      echo $(isMain) # outputs True

Uma expressão pode ser literal, uma referência a uma variável, uma referência a uma dependência, uma função, ou uma combinação aninhada válida destas.

Literais

Como parte de uma expressão, você pode usar boolean, nulo, número, corda ou versão literal.

# Examples
variables:
  someBoolean: ${{ true }} # case insensitive, so True or TRUE also works
  someNumber: ${{ -1.2 }}
  someString: ${{ 'a b c' }}
  someVersion: ${{ 1.2.3 }}

Booleano

True e False são expressões literais booleanas.

Nulo

Nulo é uma expressão literal especial que é devolvida de uma falta de dicionário, por exemplo.variables['noSuch'] O nulo pode ser a saída de uma expressão, mas não pode ser chamado diretamente dentro de uma expressão.

Número

Começa com "-", ""." ou "0" até '9'.

String

Deve ser citado de forma única. Por exemplo: 'this is a string'.

Para expressar uma única citação literal, escape-a com uma única citação. Por exemplo: 'It''s OK if they''re using contractions.'.

Pode utilizar um caracteres de tubo (|) para cordas multiline.

myKey: |
  one
  two
  three

Versão

Um número de versão com até quatro segmentos. Deve começar com um número e conter dois ou três caracteres de período (.). Por exemplo: 1.2.3.4.

Variáveis

Como parte de uma expressão, pode aceder a variáveis usando uma de duas sintaxes:

  • Sintaxe de índice: variables['MyVar']
  • Sintaxe de dereferência de propriedade: variables.MyVar

Para utilizar a sintaxe de dereferência da propriedade, o nome da propriedade deve:

  • Comece com a-Z ou _
  • Ser seguido por a-Z0-9 ou _

Dependendo do contexto de execução, estão disponíveis diferentes variáveis.

Variáveis são sempre cordas. Se pretender utilizar valores dactilografados, deve utilizar parâmetros .

Nota

Existe uma limitação para a utilização de variáveis com expressões para os gasodutos Clássico e YAML ao configurar tais variáveis através do separador UI de variáveis. As variáveis que são definidas como expressões não devem depender de outra variável com expressão em valor , uma vez que não é garantido que ambas as expressões serão devidamente avaliadas. Por exemplo, temos variável a cujo valor $[ <expression> ] é usado como parte para o valor da variável b. Uma vez que a ordem de variáveis de processamento não é variável b garantida pode ter um valor incorreto de variável a após avaliação.

As construções descritas só são permitidas enquanto as variáveis de configuração através de variáveis palavra-chave no gasoduto YAML. É necessário colocar as variáveis na ordem que devem ser processadas para obter os valores corretos após o processamento.

Funções

As seguintes funções incorporadas podem ser usadas em expressões.

e

  • Avalia se True todos os parâmetros são True
  • Min parâmetros: 2. Parâmetros max: N
  • Lança parâmetros a Boolean para avaliação
  • Curto-circuitos após o primeiro False
  • Exemplo: and(eq(variables.letters, 'ABC'), eq(variables.numbers, 123))

coalesce

  • Avalia os parâmetros em ordem e devolve o valor que não é igual a nulo ou de cadeia vazia.
  • Min parâmetros: 2. Parâmetros max: N
  • Exemplo: coalesce(variables.couldBeNull, variables.couldAlsoBeNull, 'literal so it always works')

contains

  • True Avalia se o parâmetro esquerdo String contém o parâmetro direito
  • Min parâmetros: 2. Parâmetros máximos: 2
  • Moldes para String para avaliação
  • Executa a comparação ordinal de caso de ignorção
  • Exemplo: contains('ABCDE', 'BCD') (devolve Verdadeiro)

contémValue

  • True Avalia se o parâmetro esquerdo é uma matriz, e qualquer item é igual ao parâmetro certo. Também avalia True se o parâmetro esquerdo é um objeto, e o valor de qualquer propriedade é igual ao parâmetro certo.
  • Min parâmetros: 2. Parâmetros máximos: 2
  • Se o parâmetro esquerdo for uma matriz, converta cada item para corresponder ao tipo do parâmetro certo. Se o parâmetro esquerdo for um objeto, converta o valor de cada propriedade para corresponder ao tipo de parâmetro certo. A comparação de igualdade para cada item específico avalia False se a conversão falhar.
  • Comparação ordinal de caso de ignorar para cordas
  • Curto-circuitos após a primeira partida

Nota

Não existe sintaxe literal num oleoduto YAML para especificar uma matriz. Esta função é de utilização limitada em gasodutos gerais. Destina-se a ser usado no contexto do decorador de gasodutos com matrizes fornecidas pelo sistema, como a lista de passos.

Pode usar a containsValue expressão para encontrar um valor correspondente num objeto. Aqui está um exemplo que demonstra olhar na lista de ramos de origem para uma correspondência para Build.SourceBranch.

parameters:
- name: branchOptions
  displayName: Source branch options
  type: object
  default:
    - refs/heads/main
    - refs/heads/test

jobs:
  - job: A1 
    steps:
    - ${{ each value in parameters.branchOptions }}:
      - script: echo ${{ value }}

  - job: B1 
    condition: ${{ containsValue(parameters.branchOptions, variables['Build.SourceBranch']) }}
    steps:
      - script: echo "Matching branch found"

converterToJson

  • Pegue num objeto complexo e o faça como JSON.
  • Min parâmetros: 1. Parâmetros máximos: 1.
parameters:
  - name: listOfValues
    type: object
    default:
      this_is:
        a_complex: object
        with:
          - one
          - two

steps:
- script: |
    echo "${MY_JSON}"
  env:
    MY_JSON: ${{ convertToJson(parameters.listOfValues) }}

Saída do script:

{
  "this_is": {
    "a_complex": "object",
    "with": [
      "one",
      "two"
    ]
  }
}

counter

  • Esta função só pode ser usada numa expressão que define uma variável. Não pode ser usado como parte de uma condição para um passo, trabalho ou estágio.
  • Avalia um número que é incrementado a cada execução de um oleoduto.
  • Parâmetros: 2. prefix e seed.
  • Prefixo é uma expressão de corda. Um valor separado do contador é rastreado para cada valor único de prefixo. Deve prefix utilizar caracteres UTF-16.
  • Semente é o valor inicial do balcão

Pode criar um contador que seja automaticamente aumentado por um em cada execução do seu pipeline. Quando se define um balcão, fornece-se um prefix e um seed. Aqui está um exemplo que demonstra isso.

variables:
  major: 1
  # define minor as a counter with the prefix as variable major, and seed as 100.
  minor: $[counter(variables['major'], 100)]

steps:
- bash: echo $(minor)

O valor do minor exemplo acima indicado na primeira execução do gasoduto será de 100. Na segunda corrida serão 101, desde que o valor seja major ainda 1.

Se editar o ficheiro YAML e atualizar o valor da variável major para ser 2, então na próxima execução do pipeline, o valor será de minor 100. As corridas subsequentes vão aumentar o contador para 101, 102, 103, ...

Mais tarde, se editar o ficheiro YAML e definir o valor de major volta para 1, então o valor do contador retoma onde ficou para o prefixo. Neste exemplo, retoma em 102.

Aqui está outro exemplo de definir uma variável para agir como um contador que começa a 100, é incrementado por 1 para cada corrida, e é reposto para 100 todos os dias.

Nota

pipeline.startTime não está disponível fora das expressões. pipeline.startTime formatos system.pipelineStartTime em um objeto de data e hora para que esteja disponível para trabalhar com expressões. O fuso horário padrão para pipeline.startTime é UTC. Pode mudar o fuso horário para a sua organização.

jobs:
- job:
  variables:
    a: $[counter(format('{0:yyyyMMdd}', pipeline.startTime), 100)]
  steps:
  - bash: echo $(a)

Aqui está um exemplo de ter um contador que mantém um valor separado para pRs e execuções de CI.

variables:
  patch: $[counter(variables['build.reason'], 0)]

Os contadores são traçados para um oleoduto. Por outras palavras, o seu valor é incrementado para cada execução desse gasoduto. Não há balcões com âmbito de projeto.

endsWith

  • True Avalia se o parâmetro esquerdo A corda termina com o parâmetro direito
  • Min parâmetros: 2. Parâmetros máximos: 2
  • Moldes para String para avaliação
  • Executa a comparação ordinal de caso de ignorção
  • Exemplo: endsWith('ABCDE', 'DE') (devolve Verdadeiro)

eq

  • Avalia se os True parâmetros são iguais
  • Min parâmetros: 2. Parâmetros máximos: 2
  • Converte o parâmetro direito para combinar o tipo de parâmetro esquerdo. Devoluções False se a conversão falhar.
  • Comparação ordinal de caso de ignorar para cordas
  • Exemplo: eq(variables.letters, 'ABC')

formato

  • Avalia os parâmetros de fuga e insere-os na cadeia de parâmetros líderes
  • Min parâmetros: 1. Parâmetros max: N
  • Exemplo: format('Hello {0} {1}', 'John', 'Doe')
  • Utiliza especificadores de data e formato de hora .NET para formatação de data (yyyy, yy, MMM, dHddsssHHmmm, , ffffffKf
  • Exemplo: format('{0:yyyyMMdd}', pipeline.startTime). Neste caso pipeline.startTime é uma variável de objeto de data especial.
  • Escapar duplicando aparelhos. Por exemplo: format('literal left brace {{ and literal right brace }}')

ge

  • True Avalia se o parâmetro esquerdo é maior ou igual ao parâmetro certo
  • Min parâmetros: 2. Parâmetros máximos: 2
  • Converte o parâmetro direito para combinar o tipo de parâmetro esquerdo. Erros se a conversão falhar.
  • Comparação ordinal de caso de ignorar para cordas
  • Exemplo: ge(5, 5) (devolve Verdadeiro)

gt

  • True Avalia se o parâmetro esquerdo é maior do que o parâmetro certo
  • Min parâmetros: 2. Parâmetros máximos: 2
  • Converte o parâmetro direito para combinar o tipo de parâmetro esquerdo. Erros se a conversão falhar.
  • Comparação ordinal de caso de ignorar para cordas
  • Exemplo: gt(5, 2) (devolve Verdadeiro)

para dentro

  • True Avalia se o parâmetro esquerdo é igual a qualquer parâmetro certo
  • Min parâmetros: 1. Parâmetros max: N
  • Converte os parâmetros direito para combinar o tipo de parâmetro esquerdo. A comparação da igualdade avalia False se a conversão falhar.
  • Comparação ordinal de caso de ignorar para cordas
  • Curto-circuitos após a primeira partida
  • Exemplo: in('B', 'A', 'B', 'C') (devolve Verdadeiro)

aderir

  • Concatenates todos os elementos na matriz de parâmetros direito, separados pela corda do parâmetro esquerdo.
  • Min parâmetros: 2. Parâmetros máximos: 2
  • Cada elemento da matriz é convertido numa corda. Objetos complexos são convertidos em corda vazia.
  • Se o parâmetro certo não for uma matriz, o resultado é o parâmetro certo convertido numa corda.

Neste exemplo, um ponto e vírgula é adicionado entre cada item na matriz. O tipo de parâmetro é um objeto.

parameters:
- name: myArray
  type: object
  default:
    - FOO
    - BAR
    - ZOO

variables:
   A: ${{ join(';',parameters.myArray) }}

steps:
  - script: echo $A # outputs FOO;BAR;ZOO

le

  • True Avalia se o parâmetro esquerdo é inferior ou igual ao parâmetro certo
  • Min parâmetros: 2. Parâmetros máximos: 2
  • Converte o parâmetro direito para combinar o tipo de parâmetro esquerdo. Erros se a conversão falhar.
  • Comparação ordinal de caso de ignorar para cordas
  • Exemplo: le(2, 2) (devolve Verdadeiro)

length

  • Devolve o comprimento de uma corda ou de uma matriz, ou que vem do sistema ou que vem de um parâmetro
  • Min parâmetros: 1. Parâmetros máximos 1
  • Exemplo: length('fabrikam') devoluções 8

mais baixo

  • Converte uma cadeia ou valor variável para todos os caracteres minúsculos
  • Min parâmetros: 1. Parâmetros máximos 1
  • Devolve o equivalente minúsculo de uma corda
  • Exemplo: lower('FOO') devoluções foo

lt

  • True Avalia se o parâmetro esquerdo é inferior ao parâmetro certo
  • Min parâmetros: 2. Parâmetros máximos: 2
  • Converte o parâmetro direito para combinar o tipo de parâmetro esquerdo. Erros se a conversão falhar.
  • Comparação ordinal de caso de ignorar para cordas
  • Exemplo: lt(2, 5) (devolve Verdadeiro)

ne

  • Avalia se os True parâmetros não são iguais
  • Min parâmetros: 2. Parâmetros máximos: 2
  • Converte o parâmetro direito para combinar o tipo de parâmetro esquerdo. Devoluções True se a conversão falhar.
  • Comparação ordinal de caso de ignorar para cordas
  • Exemplo: ne(1, 2) (devolve Verdadeiro)

not

  • True Avalia se o parâmetro éFalse
  • Min parâmetros: 1. Parâmetros máximos: 1
  • Converte valor para Boolean para avaliação
  • Exemplo: not(eq(1, 2)) (devolve Verdadeiro)

nãoIn

  • True Avalia se o parâmetro esquerdo não é igual a qualquer parâmetro certo
  • Min parâmetros: 1. Parâmetros max: N
  • Converte os parâmetros direito para combinar o tipo de parâmetro esquerdo. A comparação da igualdade avalia False se a conversão falhar.
  • Comparação ordinal de caso de ignorar para cordas
  • Curto-circuitos após a primeira partida
  • Exemplo: notIn('D', 'A', 'B', 'C') (devolve Verdadeiro)

ou

  • True Avalia se algum parâmetro éTrue
  • Min parâmetros: 2. Parâmetros max: N
  • Lança parâmetros a Boolean para avaliação
  • Curto-circuitos após o primeiro True
  • Exemplo: or(eq(1, 1), eq(2, 3)) (devolve verdadeiros, curto-circuitos)

substituir

  • Devolve uma nova cadeia em que todos os casos de uma corda no caso atual são substituídos por outra cadeia
  • Parâmetros min: 3. Parâmetros máximos: 3
  • replace(a, b, c): retorna a, com todas as instâncias de b substituídas por c
  • Exemplo: replace('https://www.tinfoilsecurity.com/saml/consume','https://www.tinfoilsecurity.com','http://server') (devoluções http://server/saml/consume)

startsWith

  • True Avalia se a cadeia do parâmetro esquerdo começa com o parâmetro direito
  • Min parâmetros: 2. Parâmetros máximos: 2
  • Moldes para String para avaliação
  • Executa a comparação ordinal de caso de ignorção
  • Exemplo: startsWith('ABCDE', 'AB') (devolve Verdadeiro)

superior

  • Converte uma cadeia ou valor variável para todos os caracteres maiúsculas
  • Min parâmetros: 1. Parâmetros máximos 1
  • Devolve o equivalente maiúscula de uma corda
  • Exemplo: upper('bah') devoluções BAH

xor

  • True Avalia se exatamente um parâmetro éTrue
  • Min parâmetros: 2. Parâmetros máximos: 2
  • Lança parâmetros a Boolean para avaliação
  • Exemplo: xor(True, False) (devolve Verdadeiro)

Funções de verificação do estado do trabalho

Pode utilizar as seguintes funções de verificação de estado como expressões em condições, mas não em definições variáveis.

sempre

  • True Avalia sempre (mesmo quando cancelado). Nota: Uma falha crítica pode ainda impedir que uma tarefa seja em funcionamento. Por exemplo, se as fontes falharem.

cancelado

  • Avalia se True o gasoduto foi cancelado.

falhou

  • Por um passo, equivalente a eq(variables['Agent.JobStatus'], 'Failed').
  • Para um trabalho:
    • Sem argumentos, avalia-se apenas se True algum trabalho anterior no gráfico de dependência falhou.
    • Com nomes de emprego como argumentos, só avalia se True algum desses empregos falhar.

com êxito

  • Por um passo, equivalente a in(variables['Agent.JobStatus'], 'Succeeded', 'SucceededWithIssues')
  • Use-se ao dependsOn trabalhar com empregos e quer avaliar se um trabalho anterior foi bem sucedido. Os trabalhos são concebidos para serem executados em paralelo enquanto as etapas são executadas sequencialmente.
  • Para um trabalho:
    • Sem argumentos, avalia-se True apenas se todos os trabalhos anteriores no gráfico de dependência tivessem sucesso ou fossem parcialmente bem sucedidos.
    • Com nomes de emprego como argumentos, avalia se True todos esses empregos foram bem sucedidos ou parcialmente bem sucedidos.
    • Avalia se False o gasoduto é cancelado.

sucedeuOrFailed

  • Por um passo, equivalente a in(variables['Agent.JobStatus'], 'Succeeded', 'SucceededWithIssues', 'Failed')

  • Para um trabalho:

    • Sem argumentos, avalia-se independentemente True de quaisquer trabalhos no gráfico de dependência terem sido bem sucedidos ou falhados.
    • Com nomes de emprego como argumentos, avalia se algum desses empregos True foi bem sucedido ou falhado.

    Isto é como always(), exceto que irá avaliar False quando o gasoduto é cancelado.

Inserção condicional

Pode utilizar if, elseife else cláusulas para atribuir valores variáveis condicionalmente ou definir entradas para tarefas. Você também pode executar condicionalmente um passo quando uma condição é cumprida.

Os condicionalos só funcionam quando se utiliza a sintaxe do modelo. Saiba mais sobre a sintaxe variável.

Para modelos, pode utilizar a inserção condicional ao adicionar uma sequência ou mapeamento. Saiba mais sobre a inserção condicional nos modelos.

Atribuir condicionalmente uma variável

variables:
  ${{ if eq(variables['Build.SourceBranchName'], 'main') }}: # only works if you have a main branch
    stageName: prod

pool:
  vmImage: 'ubuntu-latest'

steps:
- script: echo ${{variables.stageName}}

Definir condicionalmente uma entrada de tarefa

pool:
  vmImage: 'ubuntu-latest'

steps:
- task: PublishPipelineArtifact@1
  inputs:
    targetPath: '$(Pipeline.Workspace)'
    ${{ if eq(variables['Build.SourceBranchName'], 'main') }}:
      artifact: 'prod'
    ${{ else }}:
      artifact: 'dev'
    publishLocation: 'pipeline'

Correr um passo condicionalmente

Se não houver um conjunto variável, ou se o valor de foo não corresponder às if condições, a else declaração será executada. Aqui o valor das foo devoluções é verdadeiro na elseif condição.

variables:
  - name: foo
    value: contoso # triggers elseif condition

pool:
  vmImage: 'ubuntu-latest'

steps:
- script: echo "start"
- ${{ if eq(variables.foo, 'adaptum') }}:
  - script: echo "this is adaptum"
- ${{ elseif eq(variables.foo, 'contoso') }}: # true
  - script: echo "this is contoso" 
- ${{ else }}:
  - script: echo "the value is not adaptum or contoso"

Palavra-chave each

Pode utilizar a each palavra-chave para rodar os parâmetros com o tipo de objeto.

parameters:
- name: listOfStrings
  type: object
  default:
  - one
  - two

steps:
- ${{ each value in parameters.listOfStrings }}:
  - script: echo ${{ value }}

Dependências

As expressões podem usar o contexto de dependências para referenciar trabalhos ou estágios anteriores. Pode utilizar dependências para:

  • Referenciar o estatuto de trabalho de um trabalho anterior
  • Referenciar o estado do palco de uma fase anterior
  • Variáveis de produção de referência no trabalho anterior na mesma fase
  • Variáveis de saída de referência na fase anterior numa fase
  • Variáveis de produção de referência num trabalho numa fase anterior na fase seguinte

O contexto é chamado dependencies para empregos e estágios e funciona muito parecido com variáveis. Dentro de um trabalho, se se refere a uma variável de saída de um trabalho noutra fase, o contexto chama-se stageDependencies.

Se sentir problemas com variáveis de saída com caracteres de citação (' ou ") neles, consulte este guia de resolução de problemas.

Estágio para as dependências de palco

Estruturalmente, o dependencies objeto é um mapa de nomes de trabalho e palco para results e outputs. Expressa como JSON, pareceria:

"dependencies": {
  "<STAGE_NAME>" : {
    "result": "Succeeded|SucceededWithIssues|Skipped|Failed|Canceled",
    "outputs": {
        "jobName.stepName.variableName": "value"
    }
  },
  "...": {
    // another stage
  }
}

Utilize esta forma de dependencies mapear em variáveis ou verificar as condições a um nível de fase. Neste exemplo, a fase B corre se a fase A é bem sucedida ou ignorada.

Nota

Os exemplos a seguir utilizam a sintaxe padrão do gasoduto. Se estiver a utilizar gasodutos de implantação, a sintaxe variável variável e condicional diferirá. Para obter informações sobre a sintaxe específica a utilizar, consulte os trabalhos de implantação.

stages:
- stage: A
  condition: false
  jobs:
  - job: A1
    steps:
    - script: echo Job A1
- stage: B
  condition: in(dependencies.A.result, 'Succeeded', 'SucceededWithIssues', 'Skipped')
  jobs:
  - job: B1
    steps:
    - script: echo Job B1

As fases também podem usar variáveis de saída de outra fase. Neste exemplo, a fase B depende de uma variável na fase A.

stages:
- stage: A
  jobs:
  - job: A1
    steps:
     - bash: echo "##vso[task.setvariable variable=shouldrun;isOutput=true]true"
     # or on Windows:
     # - script: echo ##vso[task.setvariable variable=shouldrun;isOutput=true]true
       name: printvar

- stage: B
  condition: and(succeeded(), eq(dependencies.A.outputs['A1.printvar.shouldrun'], 'true'))
  dependsOn: A
  jobs:
  - job: B1
    steps:
    - script: echo hello from Stage B

Nota

Por predefinição, cada fase de um oleoduto depende da que está na mesma no ficheiro YAML. Se precisar de se referir a uma fase que não seja imediatamente anterior à atual, pode anular este padrão automático adicionando uma dependsOn secção ao palco.

Trabalho para dependências de emprego dentro de uma fase

A nível de trabalho numa única fase, os dependencies dados não contêm informação de nível de palco.

"dependencies": {
  "<JOB_NAME>": {
    "result": "Succeeded|SucceededWithIssues|Skipped|Failed|Canceled",
    "outputs": {
      "stepName.variableName": "value1"
    }
  },
  "...": {
    // another job
  }
}

Neste exemplo, Job A será sempre ignorado e Job B será executado. Job C será executado, uma vez que todas as suas dependências são bem sucedidas ou são ignoradas.

jobs:
- job: a
  condition: false
  steps:
  - script: echo Job A
- job: b
  steps:
  - script: echo Job B
- job: c
  dependsOn:
  - a
  - b
  condition: |
    and
    (
      in(dependencies.a.result, 'Succeeded', 'SucceededWithIssues', 'Skipped'),
      in(dependencies.b.result, 'Succeeded', 'SucceededWithIssues', 'Skipped')
    )
  steps:
  - script: echo Job C

Neste exemplo, Job B depende de uma variável de saída de Job A.

jobs:
- job: A
  steps:
  - bash: echo "##vso[task.setvariable variable=shouldrun;isOutput=true]true"
  # or on Windows:
  # - script: echo ##vso[task.setvariable variable=shouldrun;isOutput=true]true
    name: printvar

- job: B
  condition: and(succeeded(), eq(dependencies.A.outputs['printvar.shouldrun'], 'true'))
  dependsOn: A
  steps:
  - script: echo hello from B

Trabalho para dependências de emprego em etapas

Ao nível do trabalho, também pode referenciar saídas de um trabalho numa fase anterior. Isto requer a utilização do stageDependencies contexto.

"stageDependencies": {
  "<STAGE_NAME>" : {
    "<JOB_NAME>": {
      "result": "Succeeded|SucceededWithIssues|Skipped|Failed|Canceled",
      "outputs": {
          "stepName.variableName": "value"
      }
    },
    "...": {
      // another job
    }
  },
  "...": {
    // another stage
  }
}

Neste exemplo, o trabalho B1 funcionará se o trabalho A1 for ignorado. Job B2 verificará o valor da variável de saída do trabalho A1 para determinar se deve funcionar.

trigger: none

pool:
  vmImage: 'ubuntu-latest'

stages:
- stage: A
  jobs:
  - job: A1
    steps:
     - bash: echo "##vso[task.setvariable variable=shouldrun;isOutput=true]true"
     # or on Windows:
     # - script: echo ##vso[task.setvariable variable=shouldrun;isOutput=true]true
       name: printvar

- stage: B
  dependsOn: A
  jobs:
  - job: B1
    condition: in(stageDependencies.A.A1.result, 'Skipped') # change condition to `Succeeded and stage will be skipped`
    steps:
    - script: echo hello from Job B1
  - job: B2
    condition: eq(stageDependencies.A.A1.outputs['printvar.shouldrun'], 'true')
    steps:
     - script: echo hello from Job B2

Se um trabalho depende de uma variável definida por um trabalho de implantação numa fase diferente, então a sintaxe é diferente. No exemplo seguinte, o trabalho run_tests funciona se o build_job trabalho de destacamento definido runTests para true. Note que a chave utilizada para o outputs dicionário é build_job.setRunTests.runTests.

stages:
- stage: build
  jobs:
  - deployment: build_job
    environment:
      name: Production
    strategy:
      runOnce:
        deploy:
          steps:
          - task: PowerShell@2
            name: setRunTests
            inputs:
              targetType: inline
              pwsh: true
              script: |
                $runTests = "true"
                echo "setting runTests: $runTests"
                echo "##vso[task.setvariable variable=runTests;isOutput=true]$runTests"

- stage: test
  dependsOn:
  - 'build'
  jobs:  
    - job: run_tests
      condition: eq(stageDependencies.build.build_job.outputs['build_job.setRunTests.runTests'], 'true')
      steps:
        ...

Estágio dependendo da saída de emprego

Se não forem necessárias alterações após uma construção, é melhor saltar uma etapa num oleoduto sob determinadas condições. Um exemplo é quando está a usar o Plano Terraform, e quer desencadear a aprovação e aplicar-se apenas quando o plano contiver alterações.

Quando se usa esta condição num palco, deve utilizar a dependencies variável, não stageDependencies.

O exemplo a seguir é um simples script que define uma variável (use a sua informação real do Plano Terraform) num passo numa fase e, em seguida, invoca a segunda fase apenas se a variável tiver um valor específico.

stages:
- stage: plan_dev
  jobs:
  - job: terraform_plan_dev
    steps:
    - bash: echo '##vso[task.setvariable variable=terraform_plan_exitcode;isOutput=true]2'
      name: terraform_plan
- stage: apply_dev
  dependsOn: plan_dev
  condition: eq(dependencies.plan_dev.outputs['terraform_plan_dev.terraform_plan.terraform_plan_exitcode'], '2')
  jobs:
  - job: part_b
    steps:
    - bash: echo "BA"

Se uma fase depende de uma variável definida por um trabalho de implantação numa fase diferente, então a sintaxe é diferente. No exemplo seguinte, a fase test depende da definição shouldTest de implantação build_job para true. Note que no conditiontest palco, build_job aparece duas vezes.

stages:
- stage: build
  jobs:
  - deployment: build_job
    environment:
      name: Production
    strategy:
      runOnce:
        deploy:
          steps:
          - task: PowerShell@2
            name: setRunTests
            inputs:
              targetType: inline
              pwsh: true
              script: |
                $runTests = "true"
                echo "setting runTests: $runTests"
                echo "##vso[task.setvariable variable=runTests;isOutput=true]$runTests"

- stage: test
  dependsOn:
  - 'build'
  condition: eq(dependencies.build.outputs['build_job.build_job.setRunTests.runTests'], 'true')
  jobs:
    ...

Matrizes filtradas

Ao operar numa coleção de itens, pode utilizar a * sintaxe para aplicar uma matriz filtrada. Uma matriz filtrada devolve todos os objetos/elementos independentemente dos seus nomes.

Como exemplo, considere uma série de objetos nomeados foo. Queremos obter uma variedade dos valores da id propriedade em cada objeto na nossa matriz.

[
    { "id": 1, "a": "avalue1"},
    { "id": 2, "a": "avalue2"},
    { "id": 3, "a": "avalue3"}
]

Poderíamos fazer o seguinte:

foo.*.id

Isto indica ao sistema para funcionar como uma matriz filtrada e, em foo seguida, selecionar a id propriedade.

Isto voltaria:

[ 1, 2, 3 ]

Tipo de fundição

Os valores numa expressão podem ser convertidos de um tipo para outro à medida que a expressão é avaliada. Quando uma expressão é avaliada, os parâmetros são acossados ao tipo de dados relevante e depois transformados em cordas.

Por exemplo, neste YAML, os valores e False são convertidos True para 1 e 0 quando a expressão é avaliada. A função lt() retorna True quando o parâmetro esquerdo é inferior ao parâmetro certo.

variables:
  firstEval: $[lt(False, True)] # 0 vs. 1, True
  secondEval: $[lt(True, False)] # 1 vs. 0, False

steps:
- script: echo $(firstEval)
- script: echo $(secondEval)

Neste exemplo, os valores variables.emptyString e a corda vazia avaliam como cordas vazias. A função coalesce() avalia os parâmetros em ordem, e devolve o primeiro valor que não é igual a nulo ou cadeia vazia.

variables:
  coalesceLiteral: $[coalesce(variables.emptyString, '', 'literal value')]

steps:
- script: echo $(coalesceLiteral) # outputs literal value

As regras de conversão detalhadas são listadas mais abaixo.

De / Para Booleano Nulo Número String Versão
Booleano - - Yes Yes -
Null Yes - Yes Yes -
Number Yes - - Yes Parcial
String Yes Parcial Parcial - Parcial
Versão Yes - - Yes -

Booleano

Para numerar:

  • False0
  • True1

Para amarrar:

  • False'False'
  • True'True'

Nulo

  • Para Boolean: False
  • Para numerar: 0
  • Para corda: '' (a corda vazia)

Número

  • Para Boolean: 0False, qualquer outro número → True
  • Para ver versão: Deve ser maior do que zero e deve conter uma decimal não-zero. Deve ser inferior a Int32.MaxValue (componente decimal também).
  • Em cadeia: Converte o número numa corda sem milhares de separadores e sem separador decimal.

String

  • Para Boolean: '' (a corda vazia) → False, qualquer outra → de cordas True
  • Para anular: '' (a corda vazia) → Null, qualquer outra corda não descapotável
  • Para o número: '' (a corda vazia) → 0, caso contrário, executa C#'s Int32.TryParse usando InvariantCulture e as seguintes regras: AllowDecimalPoint | AllowLeadingSign | AllowLeadingWhite | Permitir | AllowTrailingWhite. Se TryParse falhar, não é descapotável.
  • Para a versão: executa C#'s Version.TryParse. Deve conter o componente Major e Minor no mínimo. Se TryParse falhar, não é descapotável.

Versão

  • Para Boolean: True
  • Para cadeia: Major.Minor ou Major.Minor.Build ou Major.Minor.Build.Revision.

FAQ

Quero fazer algo que não seja apoiado por expressões. Que opções tenho para alargar a funcionalidade Pipelines?

Pode personalizar o seu Pipeline com um script que inclui uma expressão. Por exemplo, este corte pega na variável e divide-a BUILD_BUILDNUMBER com Bash. Este script produz duas novas variáveis, $MAJOR_RUN e $MINOR_RUN, para os números de execução maior e menor. As duas variáveis são então usadas para criar duas variáveis de gasoduto, $major e $minor com a tarefa.setvariable. Estas variáveis estão disponíveis para passos a jusante. Para partilhar variáveis através de oleodutos ver grupos variáveis.

steps:
- bash: |
    MAJOR_RUN=$(echo $BUILD_BUILDNUMBER | cut -d '.' -f1)
    echo "This is the major run number: $MAJOR_RUN"
    echo "##vso[task.setvariable variable=major]$MAJOR_RUN"

    MINOR_RUN=$(echo $BUILD_BUILDNUMBER | cut -d '.' -f2)
    echo "This is the minor run number: $MINOR_RUN"
    echo "##vso[task.setvariable variable=minor]$MINOR_RUN"

- bash: echo "My pipeline variable for major run is $(major)"
- bash: echo "My pipeline variable for minor run is $(minor)"