jenkins学习笔记之一：流水线基础语法

1

2

3

4

参数:

. any 在任何可用的节点上执行pipeline。

. none 没有指定agent的时候默认。

. label 在指定标签上的节点上运行Pipeline。

1

2

3

这两种是—样的

agent { node { label 'labelname' }}

agent { label  'labelname '}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

声明式pipeline： 定义stages->stage。

pipeline{

agent any

stages{

    stage("GetCode"){

        //steps 

    }

    stage("build"){

       //step

    } 

}

}

脚本式Pipeline: 直接使用stage。

node("slave"){

stage("GetCode"){

    //

} 

stage("build"){

    //

}

}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

pipeline{

agent any

stages{

    stage("GetCode"){

        steps{

            sh "ls "    //step

        }       

    }   

}

}

脚本式Pipeline： 不需要step关键字。

node("slave"){

stage("GetCode"){

    //step

    if("${srcType}" == "Git"){

        //用git方式代码检出

    } else if ("${srcType}" == "SVN"){

        //用svn方式代码检出

    } else {

        error "srcType is not in [Git|SVN]"

    }

}

}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

Conditions

always

无论构建结果如何都会去执行

changed

流水线或阶段的完成状态与它之前的运行不同时执行

failure

流水线失败后执行

success

流水线成功后执行

unstable

流水线构建不稳定时执行, 通常由于测试失败,代码违规等造成。

aborted

流水线取消后执行

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

pipeline {

    agent any

    stages {

        stage('Example') {

            steps {

                echo 'Hello World'

            }

        }

    }

    post {

        always {

            echo 'I will always say Hello again!'

        }

    }

}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

agent any

//全局变量

environment {

    activeEnv = 'dev'

}

stages {

    stage('Example') {

        //局部变量

        environment {

            AN_ACCESS_KEY = credentials('my-prefined-secret-text')

        }

        steps {

            sh 'printenv'

        }

    }

}

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

buildDiscarder

为最近的流水线运行的特定数量保存组件和控制台输出。例如: options { buildDiscarder(logRotator(numToKeepStr: '1')) }

disableConcurrentBuilds

不允许同时执行流水线。 可被用来防止同时访问共享资源等。 例如: options { disableConcurrentBuilds() }

overrideIndexTriggers

允许覆盖分支索引触发器的默认处理。 如果分支索引触发器在多分支或组织标签中禁用, options { overrideIndexTriggers(true) } 将只允许它们用于促工作。否则, options { overrideIndexTriggers(false) } 只会禁用改作业的分支索引触发器。

skipDefaultCheckout

在`agent` 指令中，跳过从源代码控制中检出代码的默认情况。例如: options { skipDefaultCheckout() }

skipStagesAfterUnstable

一旦构建状态变得UNSTABLE，跳过该阶段。例如: options { skipStagesAfterUnstable() }

checkoutToSubdirectory

在工作空间的子目录中自动地执行源代码控制检出。例如: options { checkoutToSubdirectory('foo') }

timeout

设置流水线运行的超时时间, 在此之后，Jenkins将中止流水线。例如: options { timeout(time: 1, unit: 'HOURS') }

retry

在失败时, 重新尝试整个流水线的指定次数。 For example: options { retry(3) }

timestamps

预谋所有由流水线生成的控制台输出，与该流水线发出的时间一致。 例如: options { timestamps() }　

1

2

3

4

5

6

7

8

9

10

11

12

13

pipeline {

    agent any

    options {

        timeout(time: 1, unit: 'HOURS')

    }

    stages {

        stage('Example') {

            steps {

                echo 'Hello World'

            }

        }

    }

}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

string

字符串类型的参数，例如：parameters { string(name: 'DEPLOY_ENV', defaultValue: 'staging', description: '') }

text

一个文本参数，可以包含多行，例如：parameters { text(name: 'DEPLOY_TEXT', defaultValue: 'One\nTwo\nThree\n', description: '') }

booleanParam

布尔参数，例如：parameters { booleanParam(name: 'DEBUG_BUILD', defaultValue: true, description: '') }

choice

一个选择参数，例如：parameters { choice(name: 'CHOICES', choices: ['one', 'two', 'three'], description: '') }

password

密码参数，例如：parameters { password(name: 'PASSWORD', defaultValue: 'SECRET', description: 'A secret password') }

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

pipeline {

    agent any

    parameters {

        string(name: 'PERSON', defaultValue: 'Mr Jenkins', description: 'Who should I say hello to?')

        text(name: 'BIOGRAPHY', defaultValue: '', description: 'Enter some information about the person')

        booleanParam(name: 'TOGGLE', defaultValue: true, description: 'Toggle this value')

        choice(name: 'CHOICE', choices: ['One', 'Two', 'Three'], description: 'Pick something')

        password(name: 'PASSWORD', defaultValue: 'SECRET', description: 'Enter a password')

    }

    stages {

        stage('Example') {

            steps {

                echo "Hello ${params.PERSON}"

                echo "Biography: ${params.BIOGRAPHY}"

                echo "Toggle: ${params.TOGGLE}"

                echo "Choice: ${params.CHOICE}"

                echo "Password: ${params.PASSWORD}"

            }

        }

    }

}

1

2

3

4

5

6

7

8

cron

接收 cron 样式的字符串来定义要重新触发流水线的常规间隔 ,比如: triggers { cron('H */4 * * 1-5') }

pollSCM

接收 cron 样式的字符串来定义一个固定的间隔，在这个间隔中，Jenkins 会检查新的源代码更新。如果存在更改, 流水线就会被重新触发。例如: triggers { pollSCM('H */4 * * 1-5') }

upstream

接受逗号分隔的工作字符串和阈值。 当字符串中的任何作业以最小阈值结束时，流水线被重新触发。例如: triggers { upstream(upstreamProjects: 'job1,job2', threshold: hudson.model.Result.SUCCESS) }

1

2

3

4

5

6

7

8

9

10

11

12

13

pipeline {

    agent any

    triggers {

        cron('H */4 * * 1-5')

    }

    stages {

        stage('Example') {

            steps {

                echo 'Hello World'

            }

        }

    }

}

1

2

3

maven

jdk

gradle

1

2

3

4

5

6

7

8

9

10

11

12

13

pipeline {

    agent any

    tools {

        maven 'apache-maven-3.0.1'

    }

    stages {

        stage('Example') {

            steps {

                sh 'mvn --version'

            }

        }

    }

}

1

2

3

4

5

message呈现给用户的提示信息。

id可选,默认为stage名称。

ok默认表单上的ok文本。

submitter可选的,以逗号分隔的用户列表或允许提交的外部组名。默认允许任何用户submitterParameter环境变量的可选名称。如果存在,用submitter名称设置。

parameters提示提交者提供的一个可选的参数列表。　

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

agent any

stages {

    stage('Example') {

        input {

            message "Should we continue?"

            ok "Yes, we should."

            submitter "alice,bob"

            parameters {

                string(name: 'PERSON', defaultValue: 'Mr Jenkins', description: 'Who should I say hello to?')

            }

        }

        steps {

            echo "Hello, ${PERSON}, nice to meet you."

        }

    }

}　

1

2

3

4

5

6

* message 呈现给用户的提示信息。

* id 可选，默认为stage名称。

* ok 默认表单上的ok文本。

* submitter 可选的,以逗号分隔的用户列表或允许提交的外部组名。默认允许任何用户。

* submitterParameter 环境变量的可选名称。如果存在，用submitter 名称设置。

* parameters 提示提交者提供的一个可选的参数列表。

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

branch

当正在构建的分支与模式给定的分支匹配时，执行这个阶段, 例如: when { branch 'master' }。注意，这只适用于多分支流水线。

environment

当指定的环境变量是给定的值时，执行这个步骤, 例如: when { environment name: 'DEPLOY_TO', value: 'production' }

expression

当指定的Groovy表达式评估为true时，执行这个阶段, 例如: when { expression { return params.DEBUG_BUILD } }

not

当嵌套条件是错误时，执行这个阶段,必须包含一个条件，例如: when { not { branch 'master' } }

allOf

当所有的嵌套条件都正确时，执行这个阶段,必须包含至少一个条件，例如: when { allOf { branch 'master'; environment name: 'DEPLOY_TO', value: 'production' } }

anyOf

当至少有一个嵌套条件为真时，执行这个阶段,必须包含至少一个条件，例如: when { anyOf { branch 'master'; branch 'staging' } }

在进入 stage 的 agent 前评估 when

默认情况下, 如果定义了某个阶段的代理，在进入该`stage` 的 agent 后该 stage 的 when 条件将会被评估。但是, 可以通过在 when 块中指定 beforeAgent 选项来更改此选项。 如果 beforeAgent 被设置为 true, 那么就会首先对 when 条件进行评估 , 并且只有在 when 条件验证为真时才会进入 agent 。示　

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

pipeline {

    agent any

    stages {

        stage('Example Build') {

            steps {

                echo 'Hello World'

            }

        }

        stage('Example Deploy') {

            when {

                branch 'production'

            }

            steps {

                echo 'Deploying'

            }

        }

    }

}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

pipeline {

    agent any

    stages {

        stage('Example Build') {

            steps {

                echo 'Hello World'

            }

        }

        stage('Example Deploy') {

            when {

                branch 'production'

                environment name: 'DEPLOY_TO', value: 'production'

            }

            steps {

                echo 'Deploying'

            }

        }

    }

}　

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

pipeline {

    agent any

    stages {

        stage('Example Build') {

            steps {

                echo 'Hello World'

            }

        }

        stage('Example Deploy') {

            when {

                allOf {

                    branch 'production'

                    environment name: 'DEPLOY_TO', value: 'production'

                }

            }

            steps {

                echo 'Deploying'

            }

        }

    }

}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

pipeline {

    agent any

    stages {

        stage('Example Build') {

            steps {

                echo 'Hello World'

            }

        }

        stage('Example Deploy') {

            when {

                branch 'production'

                anyOf {

                    environment name: 'DEPLOY_TO', value: 'production'

                    environment name: 'DEPLOY_TO', value: 'staging'

                }

            }

            steps {

                echo 'Deploying'

            }

        }

    }

}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

pipeline {

    agent any

    stages {

        stage('Example Build') {

            steps {

                echo 'Hello World'

            }

        }

        stage('Example Deploy') {

            when {

                expression { BRANCH_NAME ==~ /(production|staging)/ }

                anyOf {

                    environment name: 'DEPLOY_TO', value: 'production'

                    environment name: 'DEPLOY_TO', value: 'staging'

                }

            }

            steps {

                echo 'Deploying'

            }

        }

    }

}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

pipeline {

    agent none

    stages {

        stage('Example Build') {

            steps {

                echo 'Hello World'

            }

        }

        stage('Example Deploy') {

            agent {

                label "some-label"

            }

            when {

                beforeAgent true

                branch 'production'

            }

            steps {

                echo 'Deploying'

            }

        }

    }

}

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

pipeline {

    agent any

    stages {

        stage('Non-Parallel Stage') {

            steps {

                echo 'This stage will be executed first.'

            }

        }

        stage('Parallel Stage') {

            when {

                branch 'master'

            }

            failFast true

            parallel {

                stage('Branch A') {

                    agent {

                        label "for-branch-a"

                    }

                    steps {

                        echo "On Branch A"

                    }

                }

                stage('Branch B') {

                    agent {

                        label "for-branch-b"

                    }

                    steps {

                        echo "On Branch B"

                    }

                }

            }

        }

    }

}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

pipeline {

    agent any

    stages {

        stage('Example') {

            steps {

                echo 'Hello World'

                script {

                    def browsers = ['chrome', 'firefox']

                    for (int i = 0; i < browsers.size(); ++i) {

                        echo "Testing the ${browsers[i]} browser"

                    }

                }

            }

        }

    }

}