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-Z
0-9
ou_
Dependendo do contexto de execução, estão disponíveis diferentes variáveis.
- Se criar oleodutos utilizando YAML, então estão disponíveis variáveis de gasoduto .
- Se criar oleodutos de construção usando editor clássico, então construa variáveis disponíveis.
- Se criar oleodutos de lançamento utilizando editor clássico, então as variáveis de lançamento estão disponí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ãoTrue
- 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 avaliaTrue
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
eseed
. - 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
,M
MM
,d
H
dd
s
ss
HH
mm
m
, ,ff
ffff
K
f
- Exemplo:
format('{0:yyyyMMdd}', pipeline.startTime)
. Neste casopipeline.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çõesfoo
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çõeshttp://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çõesBAH
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.
- Sem argumentos, avalia-se apenas se
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.
- Sem argumentos, avalia-se
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á avaliarFalse
quando o gasoduto é cancelado.- Sem argumentos, avalia-se independentemente
Inserção condicional
Pode utilizar if
, elseif
e 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 condition
test
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:
False
→0
True
→1
Para amarrar:
False
→'False'
True
→'True'
Nulo
- Para Boolean:
False
- Para numerar:
0
- Para corda:
''
(a corda vazia)
Número
- Para Boolean:
0
→False
, 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 cordasTrue
- 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#'sInt32.TryParse
usando InvariantCulture e as seguintes regras: AllowDecimalPoint | AllowLeadingSign | AllowLeadingWhite | Permitir | AllowTrailingWhite. SeTryParse
falhar, não é descapotável. - Para a versão: executa C#'s
Version.TryParse
. Deve conter o componente Major e Minor no mínimo. SeTryParse
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)"