介绍

本文介绍如何在Jenkins中使用pipeline插件。

Jenkins安装启动后，还需要安装一些插件才可以使用pipeline（流水线）的特性。你可以在系统管理–插件管理–可选插件中搜索Pipeline进行按钮；要提醒一下的是，Jenkins会自己查找依赖的插件，所以你可能看到安装的插件不只一个。Pipeline插件的wiki地址是https://wiki.jenkins.io/display/JENKINS/Pipeline+Plugin。另外，你可以通过这里https://plugins.jenkins.io/workflow-aggregator，查看该插件的依赖关系，并找到Pipeline插件在Github上的托管地址。

什么是Pipeline

Jenkins Pipeline是一套插件，支持实现和持续集成作为流水线应用到Jenkins。Pipeline提供了一套可扩展的工具。

Pipeline大致可以分为：节点、阶段、步骤。步骤是具体的功能表达式，例如：执行shell命令等。阶段，你可以理解为步骤的集合。而节点则是包含阶段，它规定了这些阶段（步骤）都会在哪些slave上运行。

节点，可以是一个普通的slave，也可以运行在Docker容器中。

为什么要用Pipeline

根本上来说，Jenkins是一个支持很多自动化模式的引擎。Pipeline增加了一套强大的工具到Jenkins中，支持用户从简单持续集成到全面的持续集成。通过模块化一些列相关的任务，用户可以利用很多Pipeline的特性。

代码：Pipelines通过代码来实现，并通常可以由版本控制系统（svn、git等）来管理。

可暂停：Pipelines可以暂停（停止），并且可以在运行之前接收人工输入或者等待同意。

Pipeline表达式

Step

是一个单一任务，告诉Jenkins该做什么。例如，在step中执行shell命令make。当一个插件扩展了Pipeline DSL，就意味着可以使用新的step。

Node

大多数工作是在一个或者多个节点（node）中完成的。

语法

Jenkins的流水线（pipeline）采用groovy语法来编写。逻辑判断、循环、异常等功能都是具备的，另外，熟悉groovy的人就明白这和Java的写法有一定的相似。

下面我介绍一些流水线的步骤（或者函数），首先介绍的是在插件workflow-basic-steps-plugin中的。我们从插件的名称上也能看到，这些流水线步骤大多是基础、简单的。首先，给出我研究时的版本信息：

<groupId>org.jenkins-ci.plugins.workflow</groupId>`
<artifactId>workflow-basic-steps</artifactId>
<version>2.7-SNAPSHOT</version>

以便各位依据本文可以进一步学习Jenkins流水线插件的源码。

环境变量

node {
    echo env.JENKINS_HOME
    sh 'echo $JENKINS_HOME'

    echo env.JOB_NAME
    echo env.NODE_NAME
    echo env.NODE_LABELS
    echo env.WORKSPACE
    echo env.JENKINS_URL
    echo env.BUILD_URL

    env.SUREN_VER = '12'
    echo env.SUREN_VER
}

上面的示例中，给出了如何使用内置的环境变量和自定义环境变量的做法

node() {
    env.JDK_HOME = "${tool '8u131'}"
    env.PATH="${env.JDK_HOME}/bin:${env.PATH}"

    echo env.JDK_HOME
    echo env.PATH
    sh 'java -version'
}

node('bimpm_deploytodev') {
    def pass_bin = '/opt/pass/bin'
    env.PASS_BIN = pass_bin

    stage('Clean') {
        sh 'rm -rfv $PASS_BIN'
    }
}

工具

node() {
    tool name: 'JDK8_Linux', type: 'jdk'
    tool name: 'maven339_linux_dir', type: 'maven'
    echo 'hello'
}

上面的pipeline指定需要工具jdk和maven的名称（在Global Tool Configuration中配置）。

对应的实现类为ToolStep，该类被final关键字所修饰，因此是不能做扩展的了。

属性

node {
    echo 'hello'
}

properties([
    buildDiscarder(
        logRotator(
            artifactDaysToKeepStr: '',
            artifactNumToKeepStr: '',
            daysToKeepStr: '5',
            numToKeepStr: '10'
        )
    ),
    pipelineTriggers([
      cron('H 3,12,17 * * *')
    ])
])

拷贝成品

node {
       stage('Copy') {
       step([$class: 'CopyArtifact', fingerprintArtifacts: true, flatten: true, projectName: 'BIM_PMJF/BIM-PMJF-BUILD/BIM_PMJF_DISCOVERY', selector: [$class: 'StatusBuildSelector', stable: false], target: '/opt/pass/bin'])
   }
}

我们通常会在一个Job里实现工程构建，在另外的Job里做程序的部署，这时候就可以用到Jenkins的成品特性。它可以实现在多个slave之间拷贝成品。实现类为ArtifactArchiverStep。

循环

node('suren') {
    def dev_path = '/opt/suren/bin'
    def services = [
        [
            'name': 'admin',
            'project': 'admin',
            'port': '7002',
            'jarName': 'admin'
        ]
    ];

    stage('Copy Artifact') {
        for(service in services){
            step([$class: 'CopyArtifact', fingerprintArtifacts: true, flatten: true,
                projectName: service.project,
                selector: [$class: 'StatusBuildSelector', stable: false],
                target: dev_path + '/' + service.name
            ])
        }
    }

    stage('Stop Service') {
        for(service in services){
           sh 'fuser -n tcp -k ' + service.port + ' > redirection &'
        }
    }

    stage('Start Service') {
        for(service in services){
            sh 'cd ' + pass_bin + '/' + service.name + ' && nohup nice java -server -Xms128m -Xmx384m \
                -jar ' + service.jarName + '.jar \
                --server.port=' + service.port + ' $> initServer.log 2>&1 &'
        }
    }
}

上面的例子，展示了如何在jenkins pipeline中调用循环语句，实现批量操作。

参数化构建

properties([[$class: 'JobRestrictionProperty'],
    parameters([run(description: '',
        filter: 'ALL', 
        name: 'Name', 
        projectName: 'Project')]),
    pipelineTriggers([])]
)

为了能让我们的流水线定义更加具有通用性，除了可以在流水线中使用系统预定义的变量外，可以使用由用户动态输入的变量值。当流水线Job加入参数化后，在执行任务时候就必须有用户输入一系列值才可以执行。

并行

node {
    stage('Start Service') {
        parallel 'test': {
            echo 'test'
        }, 'deply': {
            echo 'deply'
        }
    }

    parallel 'one' : {
        stage('one') {
            echo 'one'
        }
    }, 'two' : {
        stage('two') {
            echo 'two'
        }
    }
}

parallel 'one': {
    node{
        stage('one') {
            echo 'one'
        }
    }
}, 'two': {
    node {
        stage('two') {
            echo 'two'
        }
    }
}

Jenkins的流水线同时支持节点（node）、阶段（stage）和步骤（step）之间的并行执行。如果多个节点并发执行的话，并发数量会少于当前可用的执行器（exector）数量。

超时

node {
    stage('stage2') {
        timeout(time: 600, unit: 'SECONDS') {
            sleep 20
            echo '2'
        }
    }
}

遇到可能执行时间会比较长的情况，可以通过超时来约定最长的执行时间。

对应的实现类为TimeoutStep。

下面介绍的函数在插件workflow-durable-task-step-plugin中，版本信息如下：

<groupId>org.jenkins-ci.plugins.workflow</groupId>
<artifactId>workflow-durable-task-step</artifactId>
<version>2.18-SNAPSHOT</version>

工作空间

当你希望在一个流水线中，对多个工程（例如git工程）做构建以及部署等操作，如果不切换工作空间的话就会发生代码错乱的问题。你可以参考下面的示例代码来解决这个问题：

node{
    stage('suren'){
        ws('suren-a-work') {
            pwd
        }

        ws('suren-b-work') {
            pwd
        }
    }
}

实现类为WorkspaceStep，使用final修饰，无法扩展。

执行节点

Jenkins里可能会配置很多节点（node），而不一定所有的节点都满足你的构建环境要求，这时候就需要来指定节点了：

node('local') {
    echo 'hello'
}

properties([
    buildDiscarder(
        logRotator(
            artifactDaysToKeepStr: '',
            artifactNumToKeepStr: '',
            daysToKeepStr: '5',
            numToKeepStr: '10'
        )
    ),
    pipelineTriggers([
      cron('H 3,12,17 * * *')
    ])
])

上面的pipeline指定了运行节点的label为local。

实现类为ExecutorStep，使用final修饰，无法扩展。

异常捕获

node{
    stage('suren'){
        try{
            trigger
        }catch(error){
            echo error.getMessage()
        }
    }
}

这里调用了一个不存在的流水线函数，然后使用catch来捕获并打印错误信息。

stash

node {
    stash(name: 'test', includes: '*.xml', allowEmpty: true)
}

node('jenkins-slave') {
    unstash(name: 'test')
}

pipeline的文件存储（stash）这个功能，可以在流水线需要运行在多个节点（node）的情况下使用。stash和unstash会把存储的文件从一个节点转移到另一个节点上。上面给出的例子中，把所有的xml文件从master转移到了当前执行任务的slaver节点上。

node('jenkins-slave'){
    checkout([$class: 'GitSCM', branches: [[name: '*/master']], doGenerateSubmoduleConfigurations: false, extensions: [], submoduleCfg: [], userRemoteConfigs: [[url: 'https://github.com/LinuxSuRen/autotest.parent']]])
}

node {
    def path = JENKINS_HOME + '/jobs/' + JOB_NAME + '/builds/' + BUILD_ID
    echo path
    dir(path){
        stash(name: 'test', includes: '*.xml', allowEmpty: true)
    }
}

node('jenkins-slave') {
    unstash(name: 'test')
}

敏感信息

我们可以利用Jenkins的Credentials机制，在Pipeline中传递密码等敏感信息，例如：

pipeline {
    agent any

    stages{
        stage('test') {
            steps{
                withCredentials([usernamePassword(credentialsId: 'aaa', passwordVariable: 'passwd', usernameVariable: 'user')]) {
                    sh '''echo $user $passwd'''
                }
            }
        }
    }
}

文件读取

很多情况下，我们需要读取文件内容。

获取pom.xml版本号，获取groupId（需要的插件Pipeline Utility Steps）：

node {
    stage('test'){
        checkout([$class: 'GitSCM', branches: [[name: '*/master']], doGenerateSubmoduleConfigurations: false, extensions: [], submoduleCfg: [], userRemoteConfigs: [[url: 'https://github.com/LinuxSuRen/autotest.parent']]])

        pom = readMavenPom file: 'pom.xml'
        echo pom.version
        echo pom.groupId
        echo pom.artifactId
    }
}

使用Docker

在docker容器中执行任务：

pipeline {
    agent {
        docker {
            image 'eclipse/mysql'
            args '-e MYSQL_ROOT_PASSWORD=root'
        } 
    }

    stages {
        stage('test') {
            steps {
                sh 'mysql'
            }
        }
    }
}

withDockerContainer

withDockerServer

dockerFingerprintRun

withDockerRegistry

dockerFingerprintFrom

其他插件

另外有一些比较好的Jenkins流水线插件，给出推荐：

支持从SCM加载库文件 https://github.com/suren-jenkins/workflow-remote-loader-plugin

远程调试

安装环境：

sudo apt-get install -y npm

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

参考

https://github.com/spring-cloud/spring-cloud-pipelines