1. 基本概念

• master

master 就是 Jenkins 安装和运行的地方，它负责解析 job 脚本，处理任务，调度计算资源。

• agent

agent 负责处理从 master 分发的任务，操作实际上是通过 executor 来执行的。

• executor

executor 就是执行任务的计算资源，它可以在 master 或者 agent 上运行。多个 executor 也可以合作执行一些任务。

• step

Jenkins 里面 job 中的最小单元，可以认为是一个脚本的调用和一个插件的调用。

• node

node 可以给定参数来选择 agent，node 里的 step 将会运行在 node 选择的 agent 上。

• stage

stage 是 pipeline 里 Groovy 里引入的一个虚拟概念，是一些 step 的集合。通过 stage ，可以将 job 的全部 step 划分为不同的 stage，使得整个 job 像管道一样容易维护。

2. Groovy

Groovy 是一门动态语言，支持在 Java 平台上进行 Java 编程，使用方式基本与使用 Java 代码的方式相同。用 groovyc 编译 Groovy 代码会产生标准的 Java 字节码，然后可以通过 java 命令可以运行生成的字节码。Groovy 就是 Java，只是缺少了过去使用的许多语法规则。Groovy 是没有类型、没有修改符、没有 return、没有 Iterator、不需要导入集合的 Java。简而言之，Groovy 就是丢掉了许多包袱的 Java。

关于 Grails，就像 Rails 与 Ruby 编程语言联系非常紧密一样，Grails 是一套用于快速 Web 应用开发的开源框架。

2.1 本地开发环境

Groovy 的开发环境配置与 Java 类似。首先去，http://groovy-lang.org ，下载 SDK 包。解压之后，配置环境变量。

1
2
3
4

# 新增系统环境变量
GROOVY_HOME = D:\Groovy\groovy-2.4.12
# 在 Path 中新增
;%GROOVY_HOME%\bin;

在 command 中，输入：groovy -v。如果能显示出版本信息，说明配置成功。Groovy SDK 中提供了一个简易的编辑器，通过输入：groovyconsole，可以打开，输入：Ctrl + Enter 执行代码。

2.2 远程调用 Jenkins 执行 Pipeline

如果需要在 Atom 中利用远程 Jenkins 服务器执行 Groovy 的 pipeline 脚本，需要进行如下配置：

• 安装 NPM 包 - jenkins-pipeline

1
2

npm install -g jenkins-pipeline
apm install build

jenkins-pipeline 用于通过命令执行 Pipeline，build 是 Atom 提供的脚本执行插件，支持通过 .atom-build.yml 文件配置执行参数。

• 关闭 Jenkins 的 CSRF

如果不关闭 CSRF 跨域验证，在使用命令行调用 Jenkins 时，会提示：【No valid crumb was included in request for /job/MyTest//config.xml. Returning 403】

打开 Jenkins 的【 Manage Jenkins】-【Configure Global Security】页面，去掉 【CSRF、防止跨站点请求伪造】选项，然后保存。

• 控制台 Console 调用

使用命令行调用 shell 格式：

1

jenkins-pipeline --file <path to groovy file> --url <path-to-pipeline-job> --credentials <jenkins-username>:<jenkins-password>

在下面的例子中，使用的命令是：

1

jenkins-pipeline --file test.groovy --url http://localhost:8080/job/MyTest/ --credentials admin:123456

可以看到脚本 test.groovy 能够被执行，同时在 Jenkins 的后台界面中，也可以看到构建的执行详情，而 MyTest 项目中 pipeline 脚本内容已经被更新为 test.groovy 的内容。

• Atom 安装 Build 插件后，配置.atom-build.yml，新增如下内容：

1
2
3
4
5
6

cmd: "jenkins-pipeline"
args:
  - "--file {FILE_ACTIVE}"
  - "--url http://yourdomain.com:8080/job/MyTest/"
  - "--credentials admin:123456"
sh: true

快捷键：F9，执行 Groovy 的 pipeline 脚本。这里的 your-project-pipeline 是项目名称。

2.3 基本语法

• 注释

和 Java 一样，Groovy 使用//做单行注释，/* */做区间注释。

• 定义变量

groovy 中没有固定的类型，有点类似于弱类型的语言，变量可以通过 def 关键字引用。

1
2

def name = 'Glan'
def hello = "Hello, $name"

单引号表示这个字符串只是单纯的字符串；而双引号则可以在字符中引用变量,进行插值操作。

• 定义方法

Grooovy 的方法也是通过 def 关键字进行定义。如果不指定返回值，默认返回最后一行代码的值。

def square(def num){
    num*num
}

• 闭包

闭包， 是一种数据类型，它代表了一段可执行的代码，是 Grooovy 中一个非常重要的数据类型或者说一种概念。外型如下:

1
2
3
4
5
6
7
8

def aClosure = {
    param1, param2 ->   //箭头前边标识参数，后面是代码
    println "param2 is $param1，param2 is $param2"   //这是代码，最后一句是返回值
    //也可以使用 return 进行返回，类似于 Groovy 函数
}
//调用
aClosure.call("hello", 100)   或者
aClosure("hello", 100)

调用闭包: 闭包对象.call(参数) 或者更像函数的调用方法 : 闭包对象(参数)。

如果闭包没定义参数的话，则隐含有一个参数，这个参数名字叫 it ，和 this 的作用类似。it 代表闭包的参数。
例如:

1
2
3

def greeting = {"hello, $it"}
//等同与
def greeting = { it ->  "hello, $it"}

3. Jenkins 中使用 pipeline

Jenkins 2.0 的精髓是 pipeline，是帮助 Jenkins 实现 CI 到 CD 转变的重要角色。Jenkins定了很多内置的环境变量，查看地址： yourdomain.com:8080/pipeline-syntax/globals#env。

3.1 Pipeline 特点

Jenkins 中 pipeline 的设计理念是实现基于groovy脚本，灵活、可扩展的工作流。 具有如下特点：

• 持久性：在 Jenkins 的 master 按计划和非计划的重启后，pipeline 的 job 仍然能够工作，不受影响。
• 可暂停性：pipeline 基于 groovy 可以实现 job 的暂停和等待用户的输入或批准然后继续执行。
• 灵活的并行执行，更强的依赖控制：通过 groovy 脚本可以实现 step、stage 间的并行执行和更复杂的相互依赖关系。
• 可扩展性：通过 groovy 的编程更容易扩展插件。

3.2 安装 Pipeline

进入 Jenkins 的【Manage Jenkins】-【Manage Plugins】页面，在【Available】标签下，搜索 pipeline。勾选安装，重启后生效。

3.3 创建 Pipeline

在 Jenkins 操作页面，新建 Pipeline 项目

在 Pipeline 中输入脚本，后保存。

这里 Jenkins 提供了一份非常友好的功能，【Pipeline Syntax】用于生成符合要求的 pipeline 脚本片段。点击项目页面，左侧 【Pipeline Syntax】按钮。

在【Steps】中，选中步骤，安装提示输入相关信息，Jenkins 会自动生成选中步骤的代码 Snippet 脚本。

点击 【Build Now】，启动流水线执行。Jenkins 提供的【Full Stage View】可以查看执行的视图。

点击某次构建，比如这里的 【#10】，可以查看到 pipeline 每个 step 的执行情况。

如果安装了插件【Blue Ocean】，在项目的上方会出现一个提示【Open Blue Ocean】。点击进入：

这里可以查看 pipeline 的执行情况、可视化的编辑。BlueOcean 是 Jenkins 提供的，在执行任务时，用于降低工作流程复杂度、提升工作流程清晰度的 UI 工具。

4. pipeline 语法

4.1 关键字

下面是部分主要使用的一些关键字，pipeline 中能使用的关键字与 Jenkins 安装的插件相关。比如，安装了支持 Docker 的插件，在 pipeline 中就可以使用 withDockerContainer 等关键字。

[archive, bat, build, catchError, checkout, deleteDir, dir, dockerFingerprintFrom, dockerFingerprintRun, echo, envVarsForTool, error, fileExists, getContext, git, githubNotify, input, isUnix, library, libraryResource, load, mail, milestone, node, parallel, properties, pwd, readFile, readTrusted, resolveScm, retry, script, sh, sleep, stage, stash, step, svn, timeout, tool, unarchive, unstash, waitUntil, withContext, withCredentials, withDockerContainer, withDockerRegistry, withDockerServer, withEnv, wrap, writeFile, ws] or symbols [all, allOf, always, any, anyOf, apiToken, architecture, archiveArtifacts, artifactManager, batchFile, booleanParam, branch, buildButton, buildDiscarder, caseInsensitive, caseSensitive, certificate, choice, choiceParam, clock, cloud, command, configFile, credentials, cron, crumb, defaultView, demand, disableConcurrentBuilds, docker, dockerCert, dockerfile, downloadSettings, downstream, dumb, envVars, environment, expression, file, fileParam, filePath, fingerprint, installSource, jdk, jdkInstaller, jgit, jgitapache, jnlp, jobName, junit, lastSuccess, list, local, location, parameters, password, pattern, pipeline-model, pipelineTriggers, plainText, plugin, pollSCM, projectNamingStrategy, proxy, upstream, usernameColonPassword, usernamePassword, viewsTabBar, weather, withAnt, zfs, zip] or globals [currentBuild, docker, env, params, pipeline, scm]

4.2 结构

• stage 顺序执行

node("master"){
    stage 'one'
    echo "start one"
    sleep 1

    stage 'two'
    echo "start two"
    sleep 3

    stage 'three'
    echo "start three"
    sleep 5
}

执行结果：

 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

Started by user anonymous
[Pipeline] node
Running on master in /data/jenkins_home/workspace/MyTest
[Pipeline] {
[Pipeline] stage (one)
Using the ‘stage’ step without a block argument is deprecated
Entering stage one
Proceeding
[Pipeline] echo
start one
[Pipeline] sleep
Sleeping for 1 秒
[Pipeline] stage (two)
Using the ‘stage’ step without a block argument is deprecated
Entering stage two
Proceeding
[Pipeline] echo
start two
[Pipeline] sleep
Sleeping for 3 秒
[Pipeline] stage (three)
Using the ‘stage’ step without a block argument is deprecated
Entering stage three
Proceeding
[Pipeline] echo
start three
[Pipeline] sleep
Sleeping for 5 秒
[Pipeline] }
[Pipeline] // node
[Pipeline] End of Pipeline
Finished: SUCCESS

• stage 中并行结构

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

stage 'parallel-testing'
node("master"){
    parallel 'check one': {
        echo "start one"
        sleep 1
        echo "finish one"
    }, 'check two': {
        echo "start two"
        sleep 2
        echo "finish two"
    }, 'check three': {
        echo "start three"
        sleep 3
        echo "finish three"
    }
}

执行结果：

 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

Started by user anonymous
[Pipeline] stage (parallel-testing)
Using the ‘stage’ step without a block argument is deprecated
Entering stage parallel-testing
Proceeding
[Pipeline] node
Running on master in /data/jenkins_home/workspace/MyTest
[Pipeline] {
[Pipeline] parallel
[Pipeline] [check one] { (Branch: check one)
[Pipeline] [check two] { (Branch: check two)
[Pipeline] [check three] { (Branch: check three)
[Pipeline] [check one] echo
[check one] start one
[Pipeline] [check one] sleep
[check one] Sleeping for 1 秒
[Pipeline] [check two] echo
[check two] start two
[Pipeline] [check two] sleep
[check two] Sleeping for 2 秒
[Pipeline] [check three] echo
[check three] start three
[Pipeline] [check three] sleep
[check three] Sleeping for 3 秒
[Pipeline] [check one] echo
[check one] finish one
[Pipeline] [check one] }
[Pipeline] [check two] echo
[check two] finish two
[Pipeline] [check two] }
[Pipeline] [check three] echo
[check three] finish three
[Pipeline] [check three] }
[Pipeline] // parallel
[Pipeline] }
[Pipeline] // node
[Pipeline] End of Pipeline
Finished: SUCCESS

5. 实践建议

• 通过 groovy 脚本实现 pipeline

通过 groovy 实现的 pipeline 流程，可以将对应的 groovy 脚本存储在 Jenkinsfile 文件中，与源代码一起进行版本控制。最好在 groovy 脚本 Jenkinsfile 的第一行增加 #!groovy， 使得编辑工具能够支持 groovy 的语法高亮

• 尽可能在 stage 中实现所有的任务

pipeline 里面非配置的任务，尽量都放在 stage 块里面。通过 pipeline view 插件，可以使得 pipeline 的StageView 和 monitor 更加的清楚。

• 所有资源消耗的操作都应该放到node上执行

Jenkinsfile 里面的脚本，默认在 Jenkins master 上执行，这样会影响到 master 的服务。所以任何消耗资源的操作，都应该放在 node 中被分布到 agent 上执行。

• 尽可能地使用parallel来使得任务并行地执行

尽量使用并行任务，这样整个 job 的流程会更加快速地完成。更佳的是，并行任务在不同的 node 上执行。

• 不要在 node 里使用 input

使用 input 将暂停 pipeline 的执行，等待用户的操作。同时，如果在 node 中的 input 将使得 node 本身和 workspace 被 lock，不能够被其他 job 使用。input 应该被封装在 timeout 中。

• 使用 withEnv 来修改环境变量

不建议使用 env 来修改全局的环境变量，这样之后的脚本也会受到影响。使用 withEnv 来修改环境变量，仅在 withEnv 的块里面起作用。

• 使用 stash 来实现 stage/node 间共享文件，不要使用 archive

archive 用来实现持久的文件存储，stash 用于 stage/node 之间共享代码。

6. 参考

• https://www.ibm.com/developerworks/cn/education/java/j-groovy/j-groovy.html
• http://www.ciandcd.com/?p=164
• http://glanwang.com/2017/02/13/Gradle/Groovy%E8%AF%AD%E6%B3%95%E7%AE%80%E4%BB%8B/