2.2.1、声明式流水线

声明式Pipleine是官方推荐的语法，声明式语法更加简洁。所有的声明式Pipeline都必须包含一个 pipeline块中，比如：

  1. pipeline {
  2.     //run
  3. }

在声明式Pipeline中的基本语句和表达式遵循Groovy的语法。但是有以下例外：

  • 流水线顶层必须是一个块，特别是pipeline{}。
  • 不需要分号作为分割符，是按照行分割的。
  • 语句块只能由阶段、指令、步骤、赋值语句组成。例如: input被视为input()。

2.2.2、agent代理

agent指定了流水线的执行节点。

  1.     agent {
  2.         node {
  3.             label "master" //指定运行节点的标签或者名称
  4.             customWorkspace "${workspace}" //指定工作目录
  5.         }
  6.     }

参数：

  • any 在任何可用的节点上执行pipeline。none 没有指定agent的时候默认。
  • label 在指定标签上的节点上运行Pipeline。 node 允许额外的选项(自定义workspace)。

2.2.3、post运行后处理

当流水线完成后根据完成的状态做一些任务。例如：构建失败后邮件通知

  1. post { 
  2.     always { 
  3.         echo 'I will always say Hello again!'  //总是执行某操作
  4.     }
  5.     failure{
  6.         email : xxxx@dxx.com //失败后给某人发送邮件
  7.     }
  8. }

常用的状态：

  • always 无论流水线或者阶段的完成状态。
  • changed 只有当流水线或者阶段完成状态与之前不同时。
  • failure 只有当流水线或者阶段状态为”failure”运行。
  • success 只有当流水线或者阶段状态为”success”运行。
  • unstable 只有当流水线或者阶段状态为”unstable”运行。例如：测试失败。
  • aborted 只有当流水线或者阶段状态为”aborted “运行。例如：手动取消。

2.2.4、stages阶段

stages是流水线的整个运行阶段，包含一个或多个 stage , 建议 stages 至少包含一个 stage。

  1. stages { 
  2.     stage('Example') {
  3.         steps {
  4.             echo 'Hello World'
  5.         }
  6.     }
  7. }

2.2.5、environment环境变量

定义流水线环境变量，可以定义在全局变量或者步骤中的局部变量。这取决于 environment 指令在流水线内的位置。

  1. agent any
  2. //全局变量
  3. environment { 
  4.     activeEnv = 'dev'
  5. }
  6. stages {
  7.     stage('Example') {
  8.         //局部变量
  9.         environment { 
  10.             AN_ACCESS_KEY = credentials('my-prefined-secret-text') 
  11.         }
  12.         steps {
  13.             sh 'printenv'
  14.         }
  15.     }
  16. }

2.2.6、options运行选项

定义流水线运行时的配置选项，流水线提供了许多选项, 比如buildDiscarder,但也可以由插件提供, 比如 timestamps。

  1. agent any
  2. options {
  3.     timeout(time: 1, unit: 'HOURS') 
  4. }
  5. stages {
  6.     stage('Example') {
  7.         steps {
  8.             echo 'Hello World'
  9.         }
  10.     }
  11. }

其他部分参数：

  • buildDiscarder: 为最近的流水线运行的特定数量保存组件和控制台输出。
  • disableConcurrentBuilds: 不允许同时执行流水线。 可被用来防止同时访问共享资源等。
  • overrideIndexTriggers: 允许覆盖分支索引触发器的默认处理。
  • skipDefaultCheckout: 在agent 指令中，跳过从源代码控制中检出代码的默认情况。
  • skipStagesAfterUnstable: 一旦构建状态变得UNSTABLE，跳过该阶段。
  • checkoutToSubdirectory: 在工作空间的子目录中自动地执行源代码控制检出。
  • timeout: 设置流水线运行的超时时间, 在此之后，Jenkins将中止流水线。
  • retry: 在失败时, 重新尝试整个流水线的指定次数。
  • timestamps 预测所有由流水线生成的控制台输出，与该流水线发出的时间一致。

2.2.7、parameters参数

为流水线运行时设置项目相关的参数，就不用在UI界面上定义了，比较方便。

  1. //string 字符串类型的参数, 例如:
  2. parameters { string(name: 'DEPLOY_ENV', defaultValue: 'staging', description: '') }
  3. //booleanParam 布尔参数, 例如:
  4. parameters { booleanParam(name: 'DEBUG_BUILD', defaultValue: true, description: '') }
  1. agent any
  2. parameters {
  3.     string(name: 'PERSON', defaultValue: 'Mr Jenkins', description: 'Who should I say hello to?')
  4. }
  5. stages {
  6.     stage('Example') {
  7.         steps {
  8.             echo "Hello ${params.PERSON}"
  9.         }
  10.     }
  11. }

2.2.8、trigger触发器

构建触发器

  1. //cron 计划任务定期执行构建。
  2. triggers { cron('H */4 * * 1-5') }
  3. //pollSCM 与cron定义类似，但是由jenkins定期检测源码变化。
  4. triggers { pollSCM('H */4 * * 1-5') }
  5. agent any
  6. triggers {
  7.     cron('H */4 * * 1-5')
  8. }
  9. stages {
  10.     stage('Example') {
  11.         steps {
  12.             echo 'Hello World'
  13.         }
  14.     }
  15. }

2.2.9、tool构建工具

构建工具maven、ant、gradle,获取通过自动安装或手动放置工具的环境变量。支持maven/jdk/gradle。工具的名称必须在系统设置->全局工具配置中定义。

  1. agent any
  2. tools {
  3.     maven 'apache-maven-3.0.1' 
  4. }
  5. stages {
  6.     stage('Example') {
  7.         steps {
  8.             sh 'mvn --version'
  9.         }
  10.     }
  11. }

2.2.10、input交互输入

input用户在执行各个阶段的时候，由人工确认是否继续进行。

  1. agent any
  2. stages {
  3.     stage('Example') {
  4.         input {
  5.             message "Should we continue?"
  6.             ok "Yes, we should."
  7.             submitter "alice,bob"
  8.             parameters {
  9.                 string(name: 'PERSON', defaultValue: 'Mr Jenkins', description: 'Who should I say hello to?')
  10.             }
  11.         }
  12.         steps {
  13.             echo "Hello, ${PERSON}, nice to meet you."
  14.         }
  15.     }
  16. }

参数解释：

  • message 呈现给用户的提示信息。
  • id 可选，默认为stage名称。
  • ok 默认表单上的ok文本。
  • submitter 可选的,以逗号分隔的用户列表或允许提交的外部组名。默认允许任何用户。
  • submitterParameter 环境变量的可选名称。如果存在，用submitter 名称设置。
  • parameters 提示提交者提供的一个可选的参数列表。

2.2.11、when条件判断

when 指令允许流水线根据给定的条件决定是否应该执行阶段。 when 指令必须包含至少一个条件。

  1. //branch: 当正在构建的分支与模式给定的分支匹配时，执行这个阶段,这只适用于多分支流水线例如:
  2. when { branch 'master' }
  3. //environment: 当指定的环境变量是给定的值时，执行这个步骤,例如:
  4. when { environment name: 'DEPLOY_TO', value: 'production' }
  5. //expression 当指定的Groovy表达式评估为true时，执行这个阶段, 例如:
  6. when { expression { return params.DEBUG_BUILD } }
  7. //not 当嵌套条件是错误时，执行这个阶段,必须包含一个条件，例如:
  8. when { not { branch 'master' } }
  9. //allOf 当所有的嵌套条件都正确时，执行这个阶段,必须包含至少一个条件，例如:
  10. when { allOf { branch 'master'; environment name: 'DEPLOY_TO', value: 'production' } }
  11. //anyOf 当至少有一个嵌套条件为真时，执行这个阶段,必须包含至少一个条件，例如:
  12. when { anyOf { branch 'master'; branch 'staging' } }
  13. stage('Example Deploy') {
  14.     when {
  15.         branch 'production'
  16.         environment name: 'DEPLOY_TO', value: 'production'
  17.     }
  18.     steps {
  19.         echo 'Deploying'
  20.     }
  21. }

2.2.12、parallel并行

声明式流水线的阶段可以在他们内部声明多隔嵌套阶段, 它们将并行执行。 注意，一个阶段必须只有一个 steps 或 parallel的阶段。 嵌套阶段本身不能包含 进一步的 parallel 阶段, 但是其他的阶段的行为与任何其他 stageparallel 的阶段不能包含 agent 或 tools阶段, 因为他们没有相关 steps。

  1. stage('Parallel Stage') {
  2.     when {
  3.         branch 'master'
  4.     }
  5.     failFast true
  6.     parallel {
  7.         stage('Branch A') {
  8.             agent {
  9.                 label "for-branch-a"
  10.             }
  11.             steps {
  12.                 echo "On Branch A"
  13.             }
  14.         }
  15.         stage('Branch B') {
  16.             agent {
  17.                 label "for-branch-b"
  18.             }
  19.             steps {
  20.                 echo "On Branch B"
  21.             }
  22.         }
  23.     }
  24. }

failFast true 当其中一个进程失败时，强制所有的 parallel 阶段都被终止。

2.2.13、script脚本标签

可以通过此标签嵌入脚本式语法。

  1. stage("Build"){
  2.     steps{
  3.         script{
  4.             println("运行构建")
  5.         }
  6.     }
  7. }

2.2.14、jenkinsfile模板

  1. String workspace = "/opt/jenkins/workspace"
  2. //Pipline
  3. pipeline {
  4.     agent {
  5.         node {
  6.             label "master" //指定运行节点的标签或者名称
  7.             customWorkspace "${workspace}"
  8.         }
  9.     }
  10.     //string 字符串类型的参数, 例如:
  11.     parameters { 
  12.         string(name: 'DEPLOY_ENV', defaultValue: 'staging', description: '') 
  13.     }
  15.     triggers {
  16.         cron('H */4 * * 1-5')
  17.     }
  18.     options {
  19.         timestamps() //日志会有时间
  20.         skipDefaultCheckout() //删除隐藏checkout scm语句
  21.         disableConcurrentBuilds() //禁止并行
  22.         timeout(time: 1, unit: 'HOURS') //流水线超时设置1h
  23.     }
  24.     stages {
  26.         //下载代码
  27.         stage("GetCode"){//阶段名称
  28.             when {
  29.                 environment name: 'test', value: 'abcd'  //当test值=abcd时，执行下面step操作
  30.             }
  31.             input {
  32.                 message "Should we continue?"
  33.                 ok "Yes, we should."
  34.                 submitter "alice,bob"
  35.                 parameters {
  36.                     string(name: 'PERSON', defaultValue: 'Mr Jenkins', description: 'Who should I say hello to?')
  37.                 }
  38.             }
  39.             steps{//步骤
  40.                 timeout(time:5, unit: "MINUTES"){//步骤超时时间
  41.                     script{//填写运动代码
  42.                         println('获取代码')
  43.                         println("${test}")
  44.                         echo "Hello ${params.DEPLOY_ENV}"
  45.                         mvnHome = tool "m2"
  46.                         javaHome = tool "jdk"
  47.                         println(mvnHome)
  48.                         sh "${mvnHome}/bin/mvn --version"
  49.                         echo "Hello, ${PERSON}, nice to meet you."
  50.                     }
  51.                 }
  53.             }
  54.         }
  55.         //构建
  56.         stage("Build"){//阶段名称
  57.             steps{//步骤
  58.                 timeout(time:20, unit: "MINUTES"){//步骤超时时间
  59.                     script{//填写运动代码
  60.                         println('应用打包')
  61.                     }
  62.                 }
  64.             }
  65.         }
  66.         //并行构建
  67.         stage("Buildmerge"){//阶段名称
  68.             failFast true // 当其中一个进程失败时，强制所有的 parallel 阶段都被终止
  69.             parallel {
  70.                 stage("Build01"){//阶段名称
  71.                     steps{//步骤
  72.                         timeout(time:20, unit: "MINUTES"){//步骤超时时间
  73.                             script{//填写运动代码
  74.                                 println('应用打包并行一')
  75.                             }
  76.                         }
  77.                     }
  78.                 }
  79.                 stage("Build02"){//阶段名称
  80.                     steps{//步骤
  81.                         timeout(time:20, unit: "MINUTES"){//步骤超时时间
  82.                             script{//填写运动代码
  83.                                 println('应用打包并行二')
  84.                             }
  85.                         }
  86.                     }
  87.                 }
  88.             }
  89.         }            
  91.         //代码扫描
  92.         stage("CodeScan"){//阶段名称
  93.             steps{//步骤
  94.                 timeout(time:30, unit: "MINUTES"){//步骤超时时间
  95.                     script{//填写运动代码
  96.                         println('代码扫描')
  97.                     }
  98.                 }
  100.             }
  101.         }
  102.     }
  103.     post {
  104.         always {
  105.             script {
  106.                 println("always")
  107.             }
  108.         }
  109.         success {
  110.             script {
  111.                 currentBuild.description = "\n 构建成功"
  112.             }
  113.         }
  114.         failure {
  115.             script {
  116.                 currentBuild.description = "\n 构建失败"
  117.             }
  118.         }
  119.         aborted {
  120.             script {
  121.                 currentBuild.description = "\n 构建取消"
  122.             }
  123.         }
  124.     }
  125. }

2.2、Jenkins流水线语法 - 图1

2.2、Jenkins流水线语法 - 图2

2.2、Jenkins流水线语法 - 图3

2.2、Jenkins流水线语法 - 图4