Linux自动化--Jenkins构建之 1.Pipline详解

注：为方便讲解，Jenkins仪表盘语言显示调节为中文，如使用英文仪表盘同版本Jenkins仪表盘图标和位置为相同的。

1.Jenkins-Credentials

可以理解为“钥匙”，比如以git（版本控制器）为例来进行说明，当访问gitlab时，gitlab是需要提供相应登录的的账号与密码。那么假如说我们把要访问的URL（*.git.project-shell.git）地址理解为锁，那么所提供的账号与密码就对应于开这把锁的钥匙（无论是用ssh认证，http或者https方式认证），所以说“Credentials”中所记录的这类钥匙，而该钥匙（凭据）对应的锁是有多种可能的，可能是git，也可能是SVN等，而“Credentials”就是对于这些钥匙所进行的统一管理。

注：全局凭据/凭据都可以作为认证方式，不同的是，全局凭据在整个Jenkins总项目中的任何项目可以调用凭据作为认证，而在某个项目中创建非全局凭据仅用于该项目的认证，如果是个人人账号则更为安全。

1.1 添加Credentials

[root@jenkins-server1 ~]# cat /root/.ssh/id_rsa

2. Jenkins-Pipeline流水线

jenkins的pipeline功能，在一线企业收到广泛的应用；

Jenkins Pipeline ：Pipeline，简言之，就是一套运行于Jenkins上的工作流框架，将原本独立运行于单个或者多个节点的任务连接起来，实现单个任务难以完成的复杂流程编排与可视化，即通过Jenkins相关流程、配置、插件工具等，行程一套自动化的流水线，大大节约人工。

Pipeline是Jenkins2.X的最核心的特性，帮助Jenkins实现从CI到CD与DevOps的转变 ，Pipeline是一组插件，让Jenkins可以实现持续交付管道的落地和实施。

持续交付管道（CD Pipeline）是将软件从版本控制阶段到交付给用户或客户的完整过程的自动化表现。软件的每一次更改（提交到源代码管理系统）都要经过一个复杂的过程才能被发布。

Pipeline提供了一组可扩展的工具，通过Pipeline Domain Specific Language（DSL）syntax可以达到Pipeline as Code（Jenkinsfile存储在项目的源代码库）的目的。

2.1 Jenlins Pipeline的基础语法

Pipeline脚本是由Groovy语言实现（无需专门学习）

支持两种语法
Declarative 声明式（在Pipeline plugin 2.5中引入）
Scripted Pipeline 脚本式

2.2 声明式（jenkins2.5新加入的语法）

特点：
1. 最外层必须由pipline{ //do something }来进行包裹
2. 不需要分号作为分隔符，每个语句必须在一行内
3. 不能直接使用groovy语句（例如循环判断等），需要被script {}包裹

声明式pipeline案例：

pipeline {
    agent any   //没有指定agent
    stages{ 	//步骤
        stage('checkout code'){  //第一个步骤
            steps{
                sh 'echo "打印出来的标识"'
            }
        }
    }
}

pipeline{
    agent any
    stages{
        stage('mvn-version'){
            steps{
                sh 'mvn -v'
            }
        }
        stage('jdk-version'){
            steps{
                sh 'java -version'
            }
        }
    }
}

1.参数详解

agent：该部分指定整个Pipeline或特定阶段将在Jenkins环境中执行的位置，具体取决于该agent 部分的放置位置。该部分必须在pipeline块内的顶层定义 ，也可以使用在stage级。
stage：表示这个Pipeline的某一个执行阶段（使用stage使得逻辑变得更加简单明了）
steps: 包含一个或者多个在stage块中执行的step序列（在这里执行操作：运行maven或者部署等等）
environment：指定键值对，可用于step中，主要是为常量或者变量赋值，根据所在的位置来决定其作用范围（类似于java中全局和局部的概念）
options：允许执行pipeline内置的专用选项，也可以使用由插件提供的
parameters:提供触发pipeline时的参数列表
trigger：定义了触发pipeline的方式（jenkins1.x中的pollscm定时构建）
tools:自动安装工具，注意这里使用的一定是在jenkins全局配置中已经定义好了的
when：可以用来执行一些代码逻辑
post:可以根据pipeline的状态来执行一些操作

agent的一些参数如下：
any ： 在任何可用的机器上执行pipeline
none ： 当在pipeline顶层使用none时，每个stage需要指定相应的agent
agent{ label 'slave1'} 

3.agent指定

3.1 labels

pipeline{
    agent { label 'master'}  //指定在哪个节点运行，后面的步骤都在指定的节点运行
    stages{
        stage('mvn-version'){
            steps{
                sh 'mvn -v'
            }
        }
        stage('jdk-version'){
            steps{
                sh 'java -version'
            }
        }
    }
}

3.2 agent none

pipeline{
    agent none  //如果这里是none，后面每一步，都要指定运行节点
    stages{
        stage('mvn-version'){
        	agent { label 'master'}
            steps{
                sh 'mvn -v'
            }
        }
        stage('jdk-version'){
        	agent { label 'node'}
            steps{
                sh 'java -version'
            }
        }
    }
}

3.3 agent docker

pipeline {
    agent {
        docker { image 'maven:latest' }
    }
    stages {
        stage('Test') {
            steps {
                sh 'mvn -v'
            }
        }
    }
}

3.4 options

## 设置保存最近的记录
options { buildDiscarder(logRotator(numToKeepStr: '1')) }
 
## 禁止并行构建，因为用的worksapce还是同一个
options { disableConcurrentBuilds() }
 
## 跳过默认的代码检出
options { skipDefaultCheckout() }
 
## 设定流水线的超时时间(可用于阶段级别)
options { timeout(time: 1, unit: 'HOURS') }
 
## 设定流水线的重试次数(可用于阶段级别)
options { retry(3) }
 
## 设置日志时间输出(可用于阶段级别)
options { timestamps() }

#示例：
pipeline {
	agent any
    options {
        buildDiscarder(logRotator(numToKeepStr: '1'))
        disableConcurrentBuilds()
        skipDefaultCheckout()
        timeout(time: 1, unit: 'HOURS')
        timestamps()
        retry(3)
    }
    stages {
    	stage ('test1') {
    	    environment {
    	        name = 'vc'
    	    }
    		steps {
    			sh 'echo "The username  is ${name}"'
    		}
    	}
    }
}

3.5 environment

pipeline {
    agent any
    environment {
        unit_test = 'ops'
        username = 'yongchina'
        company = 'inc'
    }
    stages {
        stage('Example') {
            steps {
                sh 'echo ${username} 在 ${company} work ${unit_test}' 
            }
        }
    }
}

3.6 parameters

pipeline {
    agent any
    environment {
        unit_test = 'true'
        username = 'youngchina'
        company = 'inc'
    }
    parameters {
        string defaultValue: 'jenkins:1.1.1', description: 'version', name: 'Version', trim: true
    }
    stages {
        stage('Example') {
            steps {
                sh 'echo ${username} 在 ${company} work ${unit_test}的' 
                echo "${params.Version}"
            }
        }
    }
}

3.7 tools

// String description = "版本号"
pipeline {
    agent any
    environment {
        unit_test = 'true'
        username = 'youngchina'
        company = 'inc'
    }
    parameters {
        string defaultValue: 'jenkins:1.1.1', description: 'version', name: 'Version', trim: true
    }
    tools {
        maven 'maven-jdk8'
        jdk 'java1.8'
    }
    stages {
        stage('Example') {
            steps {
                sh 'echo ${username} 在 ${company} work ${unit_test}的' 
                echo "${params.Version}"
                sh 'java -version'
                sh 'mvn -v'
            }
        }
    }
}

3.8 Parallel并串行化

// String description = "版本号"
pipeline {
    agent any
    stages {
        stage('Stage1') {
            steps {
                sh 'echo "步骤1"'
            }
        }
        stage('并行执行的 Stage') {
            parallel {
                stage('Stage2.1') {   //Stage2.1、2.2和2.3是并行的，但是Stage2.3中的2步仍是串行的
                    // agent { label "test1" }
                    steps {
                        echo "在 agent test1 上执行的并行任务 1."
                    }
                }
                stage('Stage2.2') {
                    // agent { label "test2" }
                    steps {
                        echo "在 agent test2 上执行的并行任务 2."
                    }
                }
                stage('Stage2.3') {
                    stages {
                        stage ('串行1') {
                            steps {
                                echo "在 agent test2 上执行的串行任务 1."
                            } 
                        }
                        stage ('串行2') {
                            steps {
                                echo "在 agent test2 上执行的串行任务 2."
                            }
                        }
                    }
                }
            }
        }
    }
}

3.9 post钩子

post 步骤在Jenkins pipeline语法中是可选的，包含的是整个pipeline或阶段完成后一些附加的步骤。 比如我们希望整个pipeline执行完成之后或pipeline的某个stage执行成功后发生一封邮件，就可以使用post，可以理解为”钩子“。

根据pipeline或阶段的完成状态，post部分分成多种条件块，包括： 
• always：不论当前完成状态是什么，都执行。 
• changed：只要当前完成状态与上一次完成状态不同就执行。 
• fixed：上一次完成状态为失败或不稳定（unstable），当前完成状态为成功时执行。 
• regression：上一次完成状态为成功，当前完成状态为失败、不稳定或中止（aborted）时执行。 
• aborted：当前执行结果是中止状态时（一般为人为中止）执行。 
• failure：当前完成状态为失败时执行。 
• success：当前完成状态为成功时执行。 
• unstable：当前完成状态为不稳定时执行。 
• cleanup：清理条件块。不论当前完成状态是什么，在其他所有条件块执行完成后都执行。post部分可以同时包含多种条件块。

以下是 post 部分的完整示例

pipeline {
  agent { label 'master' }
  stages {
     stage('buildCode') {
       steps {
         echo "building all codes1"
       } 
      post {
        always {
          echo 'scp code.tar to apps'
        }
      }
     }
  }

  post {
    changed {
       echo 'pipeline post changed'
    }
    always {
       echo 'pipeline post always'
    }
    success {
       echo 'pipeline post success'
    }
    // 省略其他条件块
  }
}

//failure测试
pipeline {
  agent { label 'master' }
  stages {
     stage('buildCode') {
       steps {
         echo "building all codes1"
       } 
      post {
        always {
          sh 'mkdir /opt/a/ab'   //这一步是会失败的
        }
      }
     }
  }

  post {
    failure {
        echo 'pipeline post failure'   //会执行这一步
    }
  }
}

3.10 when

指令2： when

该when指令允许Pipeline根据给定的条件确定是否执行该阶段。该when指令必须至少包含一个条件。如果when指令包含多个条件，则所有子条件必须为舞台执行返回true。这与子条件嵌套在一个allOf条件中相同（见下面的例子）。

更复杂的条件结构可使用嵌套条件建：not，allOf或anyOf。嵌套条件可以嵌套到任意深度。When{…}是写在stage{…}里面一层条件控制，下面来看看when{…}支持的一些内置条件命令。

branch
当正在构建的分支与给出的分支模式匹配时执行阶段，例如：when { branch 'master' }。请注意，这仅适用于多分支Pipeline。

environment
当指定的环境变量设置为给定值时执行阶段，例如： when { environment name: 'DEPLOY_TO', value: 'production' }

expression
当指定的Groovy表达式求值为true时执行阶段，例如： when { expression { return params.DEBUG_BUILD } }

not
当嵌套条件为false时执行阶段。必须包含一个条件。例如：when { not { branch 'master' } }

allOf
当所有嵌套条件都为真时，执行舞台。必须至少包含一个条件。例如：when { allOf { branch 'master'; environment name: 'DEPLOY_TO', value: 'production' } }

anyOf
  当至少一个嵌套条件为真时执行舞台。必须至少包含一个条件。例如：when { anyOf { branch 'master'; branch 'staging' } }
举例一个 使用expression条件的when的代码示例。

pipeline {
    agent any
    stages {
        stage('Example Build') {
            steps {
                script {
                    echo 'Hello World'
                }
            }
        }
        stage('Example Deploy') {
            when {
                expression { 
                   return  (1 == 1) //返回值为True
                }
            }
            steps {
                echo 'Deploying'
            }
        }
    }
}

##environment测试
##environment测试
pipeline {
    agent any
    environment {
        username = 'youngchina'
    }
    stages {
        stage('Example Build') {
            steps {
                script {
                    echo 'Hello World'
                }
            }
        }
        stage('Example Deploy') {
            when {
                environment name: 'username', value: 'youngchina'
            }
            steps {
                echo 'youngchina'
            }
        }
    }
}