Azure DevOps YAML文件根据不同的stage,job,task的输出变量,condition不同的stage,job,task_azure devops 变量

内容介绍

可能有的小伙伴看完标题会一脸懵，这到底要讲啥呀。ok,现在我们就总体介绍一下。
在DevOps的YAML文件中，我们有些task之间，或者 job之间，stage之间有依赖性，比如我得到上一个job的一个输出变量是0,我们就需要执行job1，但如果输出变量值是1，这就是另外一种结果，我们就需要去执行job2,将job1跳过去。task，stage也是一样的。我们今天所要讲的是怎么实现这个过程。

资源准备

我们需要一个Azure Devops账号
一台编译机（self host agent/微软提供的代理机）
一个组织，一个AzureRepos仓库

结构关系

stage -> job -> step -> task
stage : 最大的，也称作阶段，我们可以理解为编译阶段，测试阶段，部署阶段。
job : 作业，每一个阶段里可能需要有很多个作业去完成这一阶段的任务。
step ： 步骤，每一个作业里可能需要很多个步骤去完成这个作业
task : 任务，其实不一定是task，还有script，bash… 这些都任务

代码书写（task）

首先我们来搞task,其实编译机会按照你在YAML里面写task的顺序去执行每一步的task。我们登录到Azure DevOps门户。
然后我们点击pipelines -> create pipelines 开始创建我们第一个管道。

然后我们选择第一个Azure Repos Git

然后我们可以选择一个仓库，然后我们可以直接点击开始使用pipeline

这样我们就自己来写里面的内容：
我们出来的内容如下
触发条件，代理池
这里我使用的是微软提供的。这些都可以保持默认。

然后我们将下面代码贴到自己Yaml上面。

# Starter pipeline
# Start with a minimal pipeline that you can customize to build and deploy your code.
# Add steps that build, run tests, deploy, and more:
# https://aka.ms/yaml

trigger:
- main

pool:
  vmImage: ubuntu-latest
 
jobs:
- job:
  steps:
  - powershell: 
      echo "##vso[task.setvariable variable=taskvar;isOutput=true]task 测试"
    name: varls

  - script: echo okokok
    condition: eq(variables['varls.taskvar'],'task')
    displayName: dev

  - script: |
      echo $(varls.taskvar)
    condition: eq(variables['varls.taskvar'],'task 测试') 
    displayName: test
  
  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

这里面主要注意的一个地方就是定义输出参数和获取输出变量。
因为在同一个job里面，task顺序执行，直接就可以获取到，假如不在同一个job里面则需要使用（depend on）。

task内定义变量

- powershell: 
      echo "##vso[task.setvariable variable=taskvar;isOutput=true]task 测试"
1
2

变量名为taskvar,变量值为”task 测试“
其中最重要的是参数：
isOutput=true
这证明了这个变量是输出变量。
task.setvariable variable 这个是task定义变量的固定格式。

task condition 获取变量值

这个获取变量我在官网并没有找到，但是根据理解可以写出来，在同一job里获取任务变量。
variables[‘varls.taskvar’]
其中variables是固定的所有变量。
然后我们获取使用

task的名称.变量名称

来获取变量值。
condition eq(变量值，目标值)

task 代码释义

 - powershell: 
      echo "##vso[task.setvariable variable=taskvar;isOutput=true]task 测试"
    name: varls
1
2
3

定义了一个名为taskvar的输出变量，值为：‘task 测试’
这个task名称为 varls

=======================================================

 - script: echo okokok
    condition: eq(variables['varls.taskvar'],'task')
    displayName: dev
1
2
3

先打印一下okokok看看能不能进这个task里面。
然后条件取到变量值和‘task’作比较。
task 测试 不等于 task
因此不会走这个task
同理task名为 dev

=======================================================

  - script: |
      echo $(varls.taskvar)
    condition: eq(variables['varls.taskvar'],'task 测试') 
    displayName: test
1
2
3
4

与上面的一样的。
按照我们所讲他应该跳过dev,然后直接运行test的任务。

测试task代码

然后我们运行试试：

我们可以点开test:

ok，没有问题。

代码书写（job）

其实job与task不同的一点是不同的job之间并没有直接的依赖关系，我们需要使用depend on来将他们联系起来。
代码如下：

jobs:
# Set an output variable from job A
- job: A
  pool:
    vmImage: 'windows-latest'
  steps:
  - powershell: echo "##vso[task.setvariable variable=myOutputVar;isOutput=true]job 测试"
    name: setvarStep
  - script: echo $(setvarStep.myOutputVar)
    name: echovar
    

# Map the variable into job B

- job: B
  dependsOn: A
  pool:
    vmImage: 'ubuntu-latest'
  variables:
    myVarFromJobA: $[ dependencies.A.outputs['setvarStep.myOutputVar'] ]  # map in the variable                                                                        # remember, expressions require single quotes
  condition: eq(variables.myVarFromJobA,'job 测试')
  steps:
    - script: echo  $(myVarFromJobA)
      name: printfVar
    

    
  
- job: lisong
  dependsOn: A
  pool:
    vmImage: 'ubuntu-latest'
  variables: 
    var : $[ dependencies.A.outputs['setvarStep.myOutputVar']]
  condition: ne(variables.var,'job 测试')
  steps:
    - script: echo $(var)
      name: PrintFVar
  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

job变量定义

 steps:
  - powershell: echo "##vso[task.setvariable variable=myOutputVar;isOutput=true]job 测试"
    name: setvarStep
1
2
3

其是换汤不换药与上面是一样的

job 变量值获取

 dependsOn: A
  pool:
    vmImage: 'ubuntu-latest'
  variables: 
    var : $[ dependencies.A.outputs['setvarStep.myOutputVar']]
  condition: ne(variables.var,'job 测试')
  steps:
    - script: echo $(var)
      name: PrintFVar
1
2
3
4
5
6
7
8
9

1.我们之前也说过获取值时需要dependsOn: job名称
我们需要告诉他你依赖的job名称，我们定义变量的job名称叫’A’
因此这个地方：
dependsOn: A
2.我们可以定义一个变量来接受获取到的值：
variable：（这个时固定格式，代表你要定义参数了）
变量名称 ： 变量值
我们获取值的格式：

$[ dependencies.job名称.outputs['任务名称.变量名']]
1

job condition

condition使用方法都是一样的，但是获取变量值我们可以使用我们接收到的变量值：variables.var

job代码释义

job A设置了一个变量名为myOutputVar，值为：‘job 测试’,
job B 比较输出变量值等于‘job 测试’
job lisong 比较输出变量值不等于 ‘job 测试’
最后运行出来应该只运行job A ,job B
我们来看下面的结果

测试job 代码

我们点开里面的job

没问题，与预期的一样。

代码书写（stage）

总体来说stage道理和job一样的，因为他们都是没有依赖关系，而我们需要给他们去建立。

stage代码展示

# Starter pipeline
# Start with a minimal pipeline that you can customize to build and deploy your code.
# Add steps that build, run tests, deploy, and more:
# https://aka.ms/yaml

trigger:
- main

pool:
  vmImage: ubuntu-latest


stages:
- stage: ready
  jobs:
  - job: var
    steps:
    - bash:  echo "##vso[task.setvariable variable=myOutputVar;isOutput=true]stagetest"
      name: setVar
  


- stage: afterA
  dependsOn: 
  - ready
  variables:
    varls : $[ stageDependencies.ready.var.outputs['setVar.myOutputVar']]
  
  jobs:
  - job: ls 
  	condition: eq(variables.varls,'stage')
    steps: 
    - script: | 
        echo $(varls)
        echo aaaa 
      name: printfafyerA 

- stage: afterB
  dependsOn: 
  - ready
  variables:
    varsl : $[ stageDependencies.ready.var.outputs['setVar.myOutputVar']]
  
  jobs:
  - job: sl 
  	condition: ne(variables.varsl,'stage')
    steps: 
    - script: | 
        echo $(varsl)
        echo bbb 
      name: printfafyerB 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

变量定义

stages:
- stage: ready
  jobs:
  - job: var
    steps:
    - bash:  echo "##vso[task.setvariable variable=myOutputVar;isOutput=true]stagetest"
      name: setVar
1
2
3
4
5
6
7

这个stage的名称为 ‘ready’
然后参数定义同上。

变量值获取

- stage: afterA
  dependsOn: 
  - ready
  variables:
    varls : $[ stageDependencies.ready.var.outputs['setVar.myOutputVar']]
  
  jobs:
  - job: ls 
  	condition: eq(variables.varls,'stage')
    steps: 
    - script: | 
        echo $(varls)
        echo aaaa 
      name: printfafyerA 
1
2
3
4
5
6
7
8
9
10
11
12
13
14

其实都是一样的，我们需要先
dependsOn ： stage名称
或者也可以这么写：
dependsOn:

• stage名称
  然后需要定义一个参数来接受获取到的值

varls : $[ stageDependencies.stage名称.job名称.outputs['task名称.变量名']]
1

代码释义

在stage afterB 里面的condition是 'ne’而不是’eq’了，ne是不等于，eq是等于。
按道理来讲我们这个pipeline应该运行stage ready , stage afterB。

代码测试

我们点开afterB里面的job和task

ok,完美手工。
（注意： 格式引用不对，或者参数不对，有时候并不会报错，但是获取不到变量值！）