jenkins流水线学习一(语法)

声明:学习资料来源于 https://blog.csdn.net/u011541946/category_8223796.html ,本人只是做了一些归纳和练习 

一、创建项目

1、在创建项目类型时选择流水线(pipeline)项目;

2、在创建页面的pipeline区域(类型默认是pipeline script),输入框右上角有示例选择,选择其中一个后,点击保存。

3、构建

这样一个简单的流水线demo就完成了

一般我们类型选择pipeline script from SCM(pipeline来自于配置)

1、SCM选择Git

2、填写好git路径和鉴权秘钥

3、脚本路径填写groove文件在git项目中的路径。比如HelloWorld.groovy文件在根目录,我直接填写HelloWorld.groovy即可

二、groovy语法

官网语法:https://jenkins.io/doc/book/pipeline/syntax/

三、关键字pipeline、agent、node、stages、stage、steps

// Declarative类型 
pipeline {
    agent any
    // 指定运行机器
    // agent {
    //     node {
    //          label "win-anthony"
    //          customWorkspace "${env.JOB_NAME}/${env.BUILD_NUMBER}"
    //     }
    // } 
    stages {
        stage('Build') { 
            steps {
                // 这里是Groovy语法,写了一个打印语句
                println "Build" 
            }
        }
        stage('Test') { 
            steps {
                // 在linux上执行
                sh "echo `pwd`"
            }
        }
        stage('Deploy') { 
            steps {
                println "Deploy" 
            }
        }
    }
}
// Scripted类型:
// 1、行数精简,很短。但是不好写,也不好读,维护起来相等困难;
// 2、没有stages这个关键字;
// 3、可以node('Node name') {}来开头,Node name就是从节点或master节点的名称
// node {  
//     stage('Build') { 
//         // 
//     }
//     stage('Test') { 
//         // 
//     }
//     stage('Deploy') { 
//         // 
//     }
// }

1、pipeline
  告诉Jenkins接下来{}中的代码就是pipeline代码,和普通的函数或者方法隔离出来。
2、agent
  代理,一般在pipeline下面,这个和选择用jenkins平台上那一台机器去执行任务构建有关;
  如果 agent 设置为none,那么stage中则需要指定 agent;  

  如果 agent 设置为指定机器,需要用到机器标签名、运行路径等信息(在jenkins的系统管理—节点管理页面,新建节点时会有这些信息填写)参考:https://blog.csdn.net/u011541946/article/details/83591148

3、node
  用来区分Jenkins环境中不同的节点环境
4、stages和 stage
  a、一个stages包含多个stage;
  b、stage指一段代码块,一般一个stage包含一个业务场景的自动化,例如build是一个stage, test是第二个stage,deploy是第三个stage;
  c、在一个Declarative Pipeline脚本中,只允许出现一次stages ;
  通过stage隔离,让Pipeline代码读写非常直观。
5、steps
  a、Declarative 模式中,不支持在steps {…} 里面嵌套写step{…} ,一个stage 下至少有一个steps,一般也就是一个steps
  b、steps指一个步骤,一般来说,一个steps{}里面就写几行代码,或者一个try catch语句

四、关键字post、environment、options、parameters、triggers、tools

pipeline {
    agent any 
    environment {
        // 定义一些变量并赋值,这些变量就是环境变量;
        unit_test = true
    }
    options {
        // options指令允许在Pipeline本身内配置Pipeline专用选项;下面示例是构建失败会执行三次
        retry(3)
    }
    parameters {
        // 提供用户在触发Pipeline时应提供的参数列表
    }
    triggers {
        // 触发条件
        pollSCM (‘H H(9-16)/2 * * 1-5)’)
    }
    tools {
        // 自动安装和放置工具的部分PATH
        jdk 'jdk8' 
    }
    stages {
        stage('Deploy') { 
            steps {
                if(unit_test == true) {
                    // call run unit test methods
                }
            }
        }
    }
    post {
        //写相关post部分代码
        always {
            script {
                //写相关清除/恢复环境等操作代码
            }
        }
    }
}

1、post
  a、和agent{…}同级,也可以放在stage里面
  b、使用post的场景基本上执行完一个构建,进行发送消息通知,例如构建失败会发邮件通知
  c、在post代码块区域,支持多种条件指令,这些指令有
    always(无论Pipeline运行的完成状态如何都会执行这段代码)、
    changed(与上一次构建的结果不同时就执行。例如,你最近几次构建都是成功,突然变成不是成功状态,里面就触发发邮件通知)、
    failure(构建失败)、
    success(构建失败)、unstable,和aborted
2、environment
  environment{…}, 定义一些变量并赋值,这些变量就是环境变量;
  作用范围取决你environment{…}所写的位置
3、options
  该options指令允许在Pipeline本身内配置Pipeline专用选项;比如retry,失败会重复执行
  作用范围取决于你写的位置
4、parameters
  jenkins项目配置中的General中的参数化构建也可以,这里是代码的方式来创建,不需要在jenkins UI上一个一个创建
  parameters指令提供用户在触发Pipeline时应提供的参数列表
5、triggers 触发器
  对于与源代码集成的Pipeline,如GitHub或BitBucket,triggers可能不需要基于webhook的集成可能已经存在。
  目前有三个可用的触发器是cron(定时任务)和pollSCM(轮询) 和 upstream
6、tools
  a、定义自动安装和放置工具的部分PATH。如果agent none指定,这将被忽略。
  b、只支持定义maven jdk gradle三种工具的环境变量。
  c、工具名称必须在Jenkins 管理Jenkins → 全局工具配置中预配置。例如,上面代码写了jdk,那么必须在jenkins管理的全局工具配置中有jdk配置

四、关键字input、when

1、input
该指令允许在一个stage{…}显示提示输入等待。
在inpt{…}写一些条件,然后用户触发构建这个job,但是这个时候没有接收到有效的input, job会一直在等待中。
需要在构建页面点击这个stage,就会弹出input中的内容

pipeline {
    agent any
    stages {
        stage('Example') {
            input {
                message "Should we continue?"
                ok "Yes, we should."
                submitter "admin,anthony"
                parameters {
                    string(name: 'PERSON', defaultValue: 'Mr Anthony', description: 'Who should I say hello to?')
                }
            }
            steps {
                echo "Hello, ${PERSON}, nice to meet you."
            }
        }
    }
}

 貌似上面的submitter限制无效

2、when
a、When{…}是写在stage{…}里面一层条件控制,根据给定的条件确定是否执行该阶段。
b、必须至少包含一个条件,且所有条件为真
c、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' } }

pipeline {
    agent any
    environment {
        quick_test = false
    }
    stages {
        stage('Example Build') {
            steps {
                script {
                    echo 'Hello World'
                }
            }
        }
        stage('Example Deploy') {
            when {
                expression { 
                   return  (quick_test == "true" )
                }
            }
            steps {
                echo 'Deploying'
            }
        }
    }
}

判断条件那里的true得带双引号,不知道为什么。因为我写false的时候不会执行后面的steps,但是带双引号的false后则会执行后面的steps

五、stage顺序嵌套
1、所有的stage,都会内嵌在最外层的stages{…}
2、一个stage{…}下可以内嵌有且只有一个stages{…}
3、多层嵌套只支持在最后一个stage{…}里面
4、嵌套越多越复杂,最简单就是观察每一个stage的大括号的范围

pipeline {
    agent none
    stages {
        stage('Non-Sequential Stage') {
            agent {
                label 'for-non-sequential'
            }
            steps {
                echo "On Non-Sequential Stage"
            }
        }
        stage('Sequential') {
            agent {
                label 'for-sequential'
            }
            environment {
                FOR_SEQUENTIAL = "some-value"
            }
            stages {
               stage('In Sequential 1') {
                   steps {
                       echo "In Sequential 1"
                   }
               }
               stage('In Sequential 2') {
                   steps {
                       echo "In Sequential 2"
                   }
               }
            }
        }
    }
}
View Code

六、stage并行
1、并行stage{…}需要用到指令paraller, 有一个paraller{…} 里面包含多个stage{…},最后一个stage{…}内部支持嵌套多个stages{…}。
2、在paraller{…}如果要设置只要里面有一个stage{…}运行失败就强制停止,可以使用表达式failFast true 来条件控制。

pipeline {
    agent any    
    stages {
        stage('Non-Parallel Stage') {
            steps {
                echo 'This stage will be executed first.'
            }
        }
        stage('Parallel Stage') {
            // 并行二给了一个错误的指令,构建时出现问题,并行三会终止
            failFast true
            parallel {
                stage('并行一') {
                    steps {
                        echo "并行一"
                    }
                }
                stage('并行二') {
                    steps {
                        // 错误的指令
                        echo1 "并行二"
                    }
                }
                stage('并行三') {
                    stages {
                        stage('Nested 1') {
                            steps {
                                echo "In stage Nested 1 within Branch C"
                            }
                        }
                        stage('Nested 2') {
                            steps {
                                echo "In stage Nested 2 within Branch C"
                            }
                        }
                    }
                }
            }
        }
    }
}
View Code

 

posted @ 2022-02-16 11:26  whitewall  阅读(1828)  评论(0编辑  收藏  举报