jenkins pipeline连接kubernetes jenkins pipeline scm

声明：学习资料来源于  ，本人只是做了一些归纳和练习 

一、创建项目

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的系统管理—节点管理页面，新建节点时会有这些信息填写）参考：

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