舍得

V1

2022/04/23阅读:17主题:橙心

Jenkins Pipeline语法

image-20220419081406065
image-20220419081406065

目录

1、初识 Pipeline 核心语法

image-20220419081505817
image-20220419081505817

1.什么是 Pipeline

image-20220419081538466
image-20220419081538466
image-20220419082541832
image-20220419082541832
  • stage:流水线中的每一个阶段;

  • agent:流水线的运行节点;

  • jenkinsfile :以代码的方式描述流水线;Jenkins 在运行 Pipeline 任务的时候会按照 Jenkinsfile 中定义的代码顺序执行;

2.创建 Pipeline 作业

🍀 作业的项目类型

1.自由风格(图形化界面)被淘汰!

image-20220419083804158
image-20220419083804158

2.Pipeline (代码)

image-20220419083834187
image-20220419083834187

注意:

jenkinsfile解决的难点、通点是:一次改变,随处可用,便于流水线的管理和维护!

自由风格:全部都要在图形化界面上进行配置的。
Pipeline:以代码方式定义流水线。

使用场景:
例如目前有250个流水线项目,如果都是自由风格类型,现在有个需求,想对这所有的项目统一配置一个参数,该如何做呢?

1、自由风格类型(1.手动傻瓜式一个个项目做哈哈  2.如果可以,可调用api进行配置)
2、流水线类型 (直接修改jenkinsfile即可实现,一次改变,随处可用效果!)

学习完pipeline之后,你可以基于公司现有的流水线进行一些改造!

🍀 要想使用这个 Pipeline 作业类型首先要安装 Pipeline 插件

image-20220419083511738
image-20220419083511738

🍀 创建 Pipeline 作业方法

image-20220419084045358
image-20220419084045358

day2-pipeline-demo

image-20220419084124757
image-20220419084124757

全局的一些选项:

image-20220419084250252
image-20220419084250252

构建触发器:

image-20220419084337699
image-20220419084337699

流水线:

第一种方式:Pipeline script

image-20220419084511956
image-20220419084511956

第二种方式:Pipeline script from SCM

3.运行第一条 Pipeline

image-20220419084650372
image-20220419084650372

🍀 亲自测试

一个 pipeline 流水线无非就是如下几个动作 1、创建一个 Pipeline 流水线项目 2、编写 Jenkinsfile 文件 3、触发构建 4、调试

这里选择一个 Hello World 测试案例,点击保存:

image-20220419085513126
image-20220419085513126

构建:

image-20220419085610383
image-20220419085610383

验证:

image-20220419085637414
image-20220419085637414
image-20220419085654430
image-20220419085654430
image-20220419085730950
image-20220419085730950

一个简单的 demo 测试结束。😘

4.调试-Pipeline-回放

image-20220419085804351
image-20220419085804351

🍀 亲自测试

image-20220419095722733
image-20220419095722733
image-20220419095736836
image-20220419095736836

这里修改下上一次构建过的 jenkinsfile 代码:

image-20220419095931339
image-20220419095931339
image-20220419100012045
image-20220419100012045
image-20220419100035914
image-20220419100035914

测试结束。

🍀 注意:如果某次的构建失败了的话,那么本次回放是不可用的,即上次的代码会丢失!(注意:推荐在本地编辑器编辑代码,然后复制到回放中就好)

image-20220420075928437
image-20220420075928437
image-20220420080126050
image-20220420080126050

5.什么是 Jenkinsfile

image-20220419100603530
image-20220419100603530
image-20220419100702910
image-20220419100702910

1、Jenkinsfile-顶级块-pipeline{}

image-20220419130008052
image-20220419130008052

2、Jenkinsfile-二级块-agent{}

image-20220419130127033
image-20220419130127033

3、Jenkinsfile-二级块-options{}

image-20220419130411596
image-20220419130411596

也就是如下的配置:

image-20220419130722393
image-20220419130722393

4、Jenkinsfile-二级块-stages{}

image-20220419130755277
image-20220419130755277

:warning: 注意

  • Jenkinsfile 支持声明式命令式2 种方式来写代码,一般推荐使用声明式。
  • 如果把命令式代码写在了 steps 里面,有的命令会报错的,因此一般要写在scriptP{}里面;
  • 这样一来的话,Jenkinsfile 就由声明式代码,内嵌一部分命令式代码组成,更加增加了其灵活性;

5、Jenkinsfile-二级块-post{}

image-20220419164820299
image-20220419164820299

示例

  • 案例代码如下
pipeline{
    //指定运行此流水线的节点
    agent { node { label "build"}}

    //管道运行选项
    options {
        skipStagesAfterUnstable()
    }
    //流水线的阶段
    stages{
        //阶段1 获取代码
        stage("CheckOut"){
            steps{
                script{
                    println("获取代码")
                }
            }
        }
        stage("Build"){
            steps{
                script{
                    println("运行构建")
                }
            }
        }
    }
    post {
        always{
            script{
                println("流水线结束后,经常做的事情")
            }
        }

        success{
            script{
                println("流水线成功后,要做的事情")
            }

        }
        failure{
            script{
                println("流水线失败后,要做的事情")
            }
        }

        aborted{
            script{
                println("流水线取消后,要做的事情")
            }

        }
    }
}

  • 将案例代码拷贝到流水线里,然后保存,立即构建即可:
image-20220419211753168
image-20220419211753168

可以运行成功,但是有个问题:

image-20220419212045374
image-20220419212045374
image-20220419212113214
image-20220419212113214
  • 我们再来使用Blue Ocean观察下现象:
image-20220419212824038
image-20220419212824038
image-20220419212951447
image-20220419212951447

测试结束。😘

2、Pipeline 开发工具

image-20220419165109656
image-20220419165109656

1.片段生成器

image-20220419213134398
image-20220419213134398

🍀 亲自测试

  • 这里随便打开一个项目,点击流水线语法,点击片段生成器
image-20220419213334453
image-20220419213334453
image-20220419213351458
image-20220419213351458
image-20220420072906176
image-20220420072906176
  • 这里来测试下,我们先来使用下echo: Print Message测试下
image-20220419214223919
image-20220419214223919

将生成的代码拷贝到源代码文件里:

pipeline{
    //指定运行此流水线的节点
    agent { node { label "build"}}

    //管道运行选项
    options {
        skipStagesAfterUnstable()
    }
    //流水线的阶段
    stages{
        //阶段1 获取代码
        stage("CheckOut"){
            steps{
                echo 'i love you ,xyy'
                script{
                    println("获取代码")
                    echo 'i love you ,xyy'
                }
            }
        }
        stage("Build"){
            steps{
                script{
                    println("运行构建")
                }
            }
        }
    }
    post {
        always{
            script{
                println("流水线结束后,经常做的事情")
            }
        }

        success{
            script{
                println("流水线成功后,要做的事情")
            }

        }
        failure{
            script{
                println("流水线失败后,要做的事情")
            }
        }

        aborted{
            script{
                println("流水线取消后,要做的事情")
            }

        }
    }
}

此时,有个问题:我将这个echo 'i love you ,xyy'语句分别写在 steps 和 script 里,那么等会构建下,是否会报错呢?

image-20220419214417209
image-20220419214417209

在上次构建地方,点击回放,将新代码拷贝进去,点击运行,观察效果:

image-20220419214647664
image-20220419214647664

可以看到,会正常构建的:

image-20220419214829033
image-20220419214829033
  • 此时,我们再选择sh: Shell Script,生成流水线脚本
image-20220420071526670
image-20220420071526670

此时,有个问题:我将这个sh 'ehco "i love you, hurt"''语句分别写在 steps 和 script 里,那么等会构建下,是否会报错呢?

pipeline{
    //指定运行此流水线的节点
    agent { node { label "build"}}

    //管道运行选项
    options {
        skipStagesAfterUnstable()
    }
    //流水线的阶段
    stages{
        //阶段1 获取代码
        stage("CheckOut"){
            steps{
                echo 'i love you ,xyy'
                sh 'echo "i love you,hurt"'
                script{
                    println("获取代码")
                    echo 'i love you ,xyy'
                    sh 'echo "i love you,hurt"'
                }
            }
        }
        stage("Build"){
            steps{
                script{
                    println("运行构建")
                }
            }
        }
    }
    post {
        always{
            script{
                println("流水线结束后,经常做的事情")
            }
        }

        success{
            script{
                println("流水线成功后,要做的事情")
            }

        }
        failure{
            script{
                println("流水线失败后,要做的事情")
            }
        }

        aborted{
            script{
                println("流水线取消后,要做的事情")
            }

        }
    }
}
image-20220420071643118
image-20220420071643118

在上次构建地方,点击回放,将新代码拷贝进去,点击运行,观察效果:

image-20220420071721930
image-20220420071721930
image-20220420071754483
image-20220420071754483

可以看到,shell 命令放在 stage 里也是不会报错的。

🍀 总结

虽然有的 shell 命令放在 stage 里也不会报错的,但是为了代码的规范性及可读性,强烈建议将 shell 命令都放在 script 里!(有可能 if else 放在 stage 里可能会报错)

image-20220420072705011
image-20220420072705011
pipeline{
    //指定运行此流水线的节点
    agent { node { label "build"}}

    //管道运行选项
    options {
        skipStagesAfterUnstable()
    }
    //流水线的阶段
    stages{
        //阶段1 获取代码
        stage("CheckOut"){
            steps{
                script{
                    println("获取代码")
                    echo 'i love you ,xyy'
                    sh 'echo "i love you,hurt"'
                }
            }
        }
        stage("Build"){
            steps{
                script{
                    println("运行构建")
                }
            }
        }
    }
    post {
        always{
            script{
                println("流水线结束后,经常做的事情")
            }
        }

        success{
            script{
                println("流水线成功后,要做的事情")
            }

        }
        failure{
            script{
                println("流水线失败后,要做的事情")
            }
        }

        aborted{
            script{
                println("流水线取消后,要做的事情")
            }

        }
    }
}

2.声明式语法生成器

image-20220420072239972
image-20220420072239972

🍀 示例

可以看到有很多 Sample Directive:

image-20220420073132156
image-20220420073132156

例如这里可以选择 agent: Agent

image-20220420073201221
image-20220420073201221
image-20220420073229033
image-20220420073229033

3.全局变量参考

image-20220420073334406
image-20220420073334406

🍀 示例

env 是全局变量的:

image-20220420073825339
image-20220420073825339
image-20220420073901706
image-20220420073901706
  • 全局变量使用测试

我们来使用下BUILD_ID这个全局变量下:

image-20220420074203796
image-20220420074203796

:warning: 注意:这里一定要使用双引号,否则会把其当做字符串打印出的!(linux 中单引号与双引号的区别)

pipeline{
    //指定运行此流水线的节点
    agent { node { label "build"}}

    //管道运行选项
    options {
        skipStagesAfterUnstable()
    }
    //流水线的阶段
    stages{
        //阶段1 获取代码
        stage("CheckOut"){
            steps{
                script{
                    println("获取代码")
                    echo 'i love you ,xyy'
                    echo "${BUILD_ID}"
                    echo "${env.BUILD_ID}"
                    echo "$BUILD_ID"
                }
            }
        }
        stage("Build"){
            steps{
                script{
                    println("运行构建")
                }
            }
        }
    }
    post {
        always{
            script{
                println("流水线结束后,经常做的事情")
            }
        }

        success{
            script{
                println("流水线成功后,要做的事情")
            }

        }
        failure{
            script{
                println("流水线失败后,要做的事情")
            }
        }

        aborted{
            script{
                println("流水线取消后,要做的事情")
            }

        }
    }
}
image-20220420074146697
image-20220420074146697

可以看到会构建成功:

image-20220420074133662
image-20220420074133662

🍀 创建全局变量并测试

我们首先将全局变量的定义放在stage里面:

image-20220420075702149
image-20220420075702149
pipeline{
    //指定运行此流水线的节点
    agent { node { label "build"}}

    //管道运行选项
    options {
        skipStagesAfterUnstable()
    }
    //流水线的阶段
    stages{
        //阶段1 获取代码
        stage("CheckOut"){
            steps{
                env.myName = "xyy"
                script{
                    println("获取代码")
                    echo 'i love you ,xyy'
                    echo "${BUILD_ID}"
                    echo "${env.BUILD_ID}"
                    echo "$BUILD_ID"
                    echo "${myName}"
                }
            }
        }
        stage("Build"){
            steps{
                script{
                    println("运行构建")
                }
            }
        }
    }
    post {
        always{
            script{
                println("流水线结束后,经常做的事情")
            }
        }

        success{
            script{
                println("流水线成功后,要做的事情")
            }

        }
        failure{
            script{
                println("流水线失败后,要做的事情")
            }
        }

        aborted{
            script{
                println("流水线取消后,要做的事情")
            }

        }
    }
}

结果构建失败了:

image-20220420075636291
image-20220420075636291

此时,我们修改下代码,再把其放在 script 里面,看能否构建成功:

image-20220420080240591
image-20220420080240591
pipeline{
    //指定运行此流水线的节点
    agent { node { label "build"}}

    //管道运行选项
    options {
        skipStagesAfterUnstable()
    }
    //流水线的阶段
    stages{
        //阶段1 获取代码
        stage("CheckOut"){
            steps{
                script{
                    env.myName = "xyy"
                    echo "${myName}"
                    println("获取代码")
                    echo 'i love you ,xyy'
                    echo "${BUILD_ID}"
                    echo "${env.BUILD_ID}"
                    echo "$BUILD_ID"

                }
            }
        }
        stage("Build"){
            steps{
                script{
                    println("运行构建")
                }
            }
        }
    }
    post {
        always{
            script{
                println("流水线结束后,经常做的事情")
            }
        }

        success{
            script{
                println("流水线成功后,要做的事情")
            }

        }
        failure{
            script{
                println("流水线失败后,要做的事情")
            }
        }

        aborted{
            script{
                println("流水线取消后,要做的事情")
            }

        }
    }
}
image-20220420080225322
image-20220420080225322

可以看到,本次构建成功,原来就是把命令式代码写在 stage 位置了,导致构建失败!因此也验证了上面的结论脚本式的语法我们都写在script里面

  • 此时,有个问题:

刚才在检出代码阶段定义的全局变量,是否可以在构建阶段里面使用?这边来测试下

image-20220420080653894
image-20220420080653894
pipeline{
    //指定运行此流水线的节点
    agent { node { label "build"}}

    //管道运行选项
    options {
        skipStagesAfterUnstable()
    }
    //流水线的阶段
    stages{
        //阶段1 获取代码
        stage("CheckOut"){
            steps{
                script{
                    env.myName = "xyy"
                    echo "${myName}"
                    env.branchName = "dev"
                    println("获取代码")
                    echo 'i love you ,xyy'
                    echo "${BUILD_ID}"
                    echo "${env.BUILD_ID}"
                    echo "$BUILD_ID"

                }
            }
        }
        stage("Build"){
            steps{
                script{
                    println("运行构建")
                    echo "${branchName}"
                }
            }
        }
    }
    post {
        always{
            script{
                println("流水线结束后,经常做的事情")
            }
        }

        success{
            script{
                println("流水线成功后,要做的事情")
            }

        }
        failure{
            script{
                println("流水线失败后,要做的事情")
            }
        }

        aborted{
            script{
                println("流水线取消后,要做的事情")
            }

        }
    }
}

image-20220420080729187
image-20220420080729187

结论:可以看到,在某一个 stage 里定义的全局变量,在其他 stage 里也是可以使用的!

🍀 示例:如何使用命令式语法来定义局部变量

image-20220420095357211
image-20220420095357211
pipeline{
    //指定运行此流水线的节点
    agent { node { label "build"}}

    //管道运行选项
    options {
        skipStagesAfterUnstable()
    }
    //流水线的阶段
    stages{
        //阶段1 获取代码
        stage("CheckOut"){
            steps{
                script{
                    envType = "test"
                    echo "envType: ${envType}"
                    env.myName = "xyy"
                    echo "${myName}"
                    env.branchName = "dev"
                    println("获取代码")
                    echo 'i love you ,xyy'
                    echo "${BUILD_ID}"
                    echo "${env.BUILD_ID}"
                    echo "$BUILD_ID"

                }
            }
        }
        stage("Build"){
            steps{
                script{
                    println("运行构建")
                    echo "${branchName}"
                    echo "envType: ${envType}"
                }
            }
        }
    }
    post {
        always{
            script{
                println("流水线结束后,经常做的事情")
            }
        }

        success{
            script{
                println("流水线成功后,要做的事情")
            }

        }
        failure{
            script{
                println("流水线失败后,要做的事情")
            }
        }

        aborted{
            script{
                println("流水线取消后,要做的事情")
            }

        }
    }
}

进行构建:

image-20220420095451385
image-20220420095451385

结论:发现在 script 里定义的局部变量,在其他 stage 里也是可以使用的。。。😥 并且,也是可以在 stage 里引用局部变量的,也是不会报错的。

3、深入 Pipeline 核心语法

image-20220420102631248
image-20220420102631248

1.agent{}流水线运行节点

image-20220420102722490
image-20220420102722490
image-20220420142212793
image-20220420142212793

🍀 注意

none 情况:适合于流水线的阶段分布在不同的 agent 上运行;

还是指定节点这种方式用的多一些;

2.stages{}流水线阶段

image-20220420142304019
image-20220420142304019

3.post{}

image-20220420142443462
image-20220420142443462

🍀 注意

  • always:例如每次执行后清理缓存动作;
  • success:执行成功后,也可触发下一动作,例如触发 CD;(远程构建)
  • failure/aborted:可能要给开发人员发个邮件。

4.enironment{}环境变量

image-20220420142927195
image-20220420142927195

推荐:声明式语法里使用 enironment 这个语句块来写。

🍀 示例:全局变量测试

编写代码:

image-20220420150316747
image-20220420150316747
pipeline{
    //指定运行此流水线的节点
    agent { node { label "build"}}

    environment{
        branchName = "dev"
        version = "1.1.1"
    }

    //流水线的阶段
    stages{
        //阶段1 获取代码
        stage("CheckOut"){
            steps{
                script{
                     echo "${branchName}"
                     echo "${version}"
                }
            }
        }
        stage("Build"){
            steps{
                script{
                    println("运行构建")
                    echo "${branchName}"
                    echo "${version}"
                }
            }
        }
    }
    post {
        always{
            script{
                println("流水线结束后,经常做的事情")
            }
        }

        success{
            script{
                println("流水线成功后,要做的事情")
            }

        }
        failure{
            script{
                println("流水线失败后,要做的事情")
            }
        }

        aborted{
            script{
                println("流水线取消后,要做的事情")
            }

        }
    }
}

立即构建:构建成功。

image-20220420150217941
image-20220420150217941

🍀 示例:局部变量测试

编写如下代码:

image-20220420152144792
image-20220420152144792
pipeline{
    //指定运行此流水线的节点
    agent { node { label "build"}}

    environment{
        branchName = "dev"
        version = "1.1.1"
    }

    //流水线的阶段
    stages{
        //阶段1 获取代码
        stage("CheckOut"){
            environment{
                branchName = "test"
            }
            steps{
                script{
                     echo "${branchName}"
                     echo "${version}"
                }
            }
        }
        stage("Build"){
            steps{
                script{
                    println("运行构建")
                    echo "${branchName}"
                    echo "${version}"
                }
            }
        }
    }
    post {
        always{
            script{
                println("流水线结束后,经常做的事情")
            }
        }

        success{
            script{
                println("流水线成功后,要做的事情")
            }

        }
        failure{
            script{
                println("流水线失败后,要做的事情")
            }
        }

        aborted{
            script{
                println("流水线取消后,要做的事情")
            }

        }
    }
}

运行:

image-20220420152102228
image-20220420152102228

注意:这里涉及到一个作用域问题,局部变量优先级高于全局变量。

5.options{}流水线运行时选项

image-20220420143010960
image-20220420143010960

🍀 注意:以上不用硬记的,需要用到时可以到声明式语法生成器那里寻找就好

image-20220420153728205
image-20220420153728205
image-20220420153838436
image-20220420153838436

6.parameters{}参数化构建

image-20220420153919329
image-20220420153919329

🍀 示例:定义字符串参数和选项参数

声明式语法生成器里选择参数构建-字符串构建:

image-20220420155052168
image-20220420155052168

代码如下:

image-20220420155746621
image-20220420155746621
pipeline{
    //指定运行此流水线的节点
    agent { node { label "build"}}

    environment{
        branchName = "dev"
        version = "1.1.1"
    }
    parameters {
        string defaultValue: '1.1.2', description: '版本号', name: 'VERSION', trim: true
    }

    //流水线的阶段
    stages{
        //阶段1 获取代码
        stage("CheckOut"){
            environment{
                branchName = "test"
            }
            steps{
                script{
                     echo "${branchName}"
                     echo "${version}"
                }
            }
        }
        stage("Build"){
            steps{
                script{
                    println("运行构建")
                    echo "${branchName}"
                    echo "${version}"
                }
            }
        }
    }
    post {
        always{
            script{
                println("流水线结束后,经常做的事情")
            }
        }

        success{
            script{
                println("流水线成功后,要做的事情")
            }

        }
        failure{
            script{
                println("流水线失败后,要做的事情")
            }
        }

        aborted{
            script{
                println("流水线取消后,要做的事情")
            }

        }
    }
}

进行构建:

image-20220420155612088
image-20220420155612088
image-20220420155722370
image-20220420155722370

在配置这里也是可以看到参数化构建的选项的:

image-20220420155651467
image-20220420155651467
  • 我们再来定义下选项参数:
image-20220420160031046
image-20220420160031046
image-20220420160310258
image-20220420160310258
pipeline{
    //指定运行此流水线的节点
    agent { node { label "build"}}

    environment{
        branchName = "dev"
        version = "1.1.1"
    }
    parameters {
        string defaultValue: '1.1.2', description: '版本号', name: 'VERSION', trim: true
        choice choices: ['prod''test''dev'], name: 'envType'
    }

    //流水线的阶段
    stages{
        //阶段1 获取代码
        stage("CheckOut"){
            environment{
                branchName = "test"
            }
            steps{
                script{
                     echo "${branchName}"
                     echo "${version}"
                }
            }
        }
        stage("Build"){
            steps{
                script{
                    println("运行构建")
                    echo "${branchName}"
                    echo "${version}"
                }
            }
        }
    }
    post {
        always{
            script{
                println("流水线结束后,经常做的事情")
            }
        }

        success{
            script{
                println("流水线成功后,要做的事情")
            }

        }
        failure{
            script{
                println("流水线失败后,要做的事情")
            }
        }

        aborted{
            script{
                println("流水线取消后,要做的事情")
            }

        }
    }
}

构建:

image-20220420160144571
image-20220420160144571
image-20220420160501641
image-20220420160501641
  • 参数定义好了,该如何引用呢?
image-20220420162519820
image-20220420162519820
pipeline{
    //指定运行此流水线的节点
    agent { node { label "build"}}

    environment{
        branchName = "dev"
        version = "1.1.1"
    }
    parameters {
        string defaultValue: '1.1.2'description: '版本号'name: 'VERSION'trim: true
        choice choices: ['prod''test''dev'], name: 'envType'
    }

    //流水线的阶段
    stages{
        //阶段1 获取代码
        stage("CheckOut"){
            // environment{
            //     branchName = "test"
            // }
            steps{
                script{
                     echo "${branchName}"
                     echo "${version}"
                     echo "${VERSION}"
                     echo "${env.VERSION}"
                     echo "${params.VERSION}"
                }
            }
        }
        stage("Build"){
            steps{
                script{
                    println("运行构建")
                    echo "${branchName}"
                    echo "${version}"
                }
            }
        }
    }
    post {
        always{
            script{
                println("流水线结束后,经常做的事情")
            }
        }

        success{
            script{
                println("流水线成功后,要做的事情")
            }

        }
        failure{
            script{
                println("流水线失败后,要做的事情")
            }
        }

        aborted{
            script{
                println("流水线取消后,要做的事情")
            }

        }
    }
}

构建:

image-20220420162547454
image-20220420162547454
  • 我们再来测试下如下现象:
image-20220420163318179
image-20220420163318179
pipeline{
    //指定运行此流水线的节点
    agent { node { label "build"}}

    environment{
        branchName = "dev"
        // version = "1.1.1"
    }
    parameters {
        string defaultValue: '1.1.2'description: '版本号'name: 'VERSION'trim: true
        choice choices: ['prod''test''dev'], name: 'envType'
    }

    //流水线的阶段
    stages{
        //阶段1 获取代码
        stage("CheckOut"){
            // environment{
            //     branchName = "test"
            // }
            steps{
                script{
                     echo "${branchName}"
                    //  echo "${version}"
                     echo "${VERSION}"
                     echo "${env.VERSION}"
                     echo "${params.VERSION}"
                }
            }
        }
        stage("Build"){
            steps{
                script{
                    println("运行构建")
                    echo "${branchName}"
                    // echo "${version}"
                }
            }
        }
    }
    post {
        always{
            script{
                println("流水线结束后,经常做的事情")
            }
        }

        success{
            script{
                println("流水线成功后,要做的事情")
            }

        }
        failure{
            script{
                println("流水线失败后,要做的事情")
            }
        }

        aborted{
            script{
                println("流水线取消后,要做的事情")
            }

        }
    }
}

构建:

image-20220420163237501
image-20220420163237501

结论:

如果同时有environmentparameters时,env.VERSIONVERSION默认会使用 enironment 的值的,因此要想使用 parameters,推荐使用params.VERSION来引用。

这里需要注意下,大小写变量问题。

7.triggers{}触发器

image-20220420183705454
image-20220420183705454

🍀 注意

image-20220420183115814
image-20220420183115814
image-20220420183244496
image-20220420183244496

定时构建:例如代码扫描。

SCM 轮询构建:之前自由风格类型用的多,现在 pipeline 用的不多了,后面会讲一个更高级的工具。(xx webhook)

8.input{}触发器

image-20220420183716917
image-20220420183716917

🍀 示例

生成代码:

image-20220420185145348
image-20220420185145348
image-20220420185205555
image-20220420185205555

编写代码:

image-20220420200034033
image-20220420200034033
pipeline{
    //指定运行此流水线的节点
    agent { node { label "build"}}
    // triggers {
    //     cron 'H 11 * * *'
    // }
    environment{
        branchName = "dev"
        // version = "1.1.1"
    }
    parameters {
        string defaultValue: '1.1.2'description: '版本号'name: 'VERSION'trim: true
        choice choices: ['prod''test''dev'], name: 'envType'
    }

    //流水线的阶段
    stages{
        //阶段1 获取代码
        stage("CheckOut"){
            // environment{
            //     branchName = "test"
            // }
            steps{
                script{
                     echo "${branchName}"
                    //  echo "${version}"
                     echo "${VERSION}"
                     echo "${env.VERSION}"
                     echo "${params.VERSION}"
                }
            }
        }
        stage("Build"){
            steps{
                script{
                    println("运行构建")
                    echo "${branchName}"
                    // echo "${version}"
                }
            }
        }
        stage("deploy"){
            input {
                message '选择开发环境'
                ok '提交'
                parameters {
                    choice choices: ['dev''prod''test'], name: 'envName'
                }

            }
            steps{
                echo "deploy ${envName}"
            }

        }
    }
    post {
        always{
            script{
                println("流水线结束后,经常做的事情")
            }
        }

        success{
            script{
                println("流水线成功后,要做的事情")
            }

        }
        failure{
            script{
                println("流水线失败后,要做的事情")
            }
        }

        aborted{
            script{
                println("流水线取消后,要做的事情")
            }

        }
    }
}

构建:

image-20220420200138690
image-20220420200138690
image-20220420200238063
image-20220420200238063

以 BlueOcean 方式打开构建过程:

image-20220420200347569
image-20220420200347569
image-20220420200359220
image-20220420200359220

🍀 注意

image-20220420200613222
image-20220420200613222

9.when{}阶段运行控制

image-20220420200437059
image-20220420200437059

🍀 示例

编写代码:

image-20220420202509125
image-20220420202509125
pipeline{
    //指定运行此流水线的节点
    agent { node { label "build"}}
    // triggers {
    //     cron 'H 11 * * *'
    // }
    environment{
        branchName = "dev"
        // version = "1.1.1"
    }
    parameters {
        string defaultValue: '1.1.2'description: '版本号'name: 'VERSION'trim: true
        choice choices: ['prod''test''dev'], name: 'envType'
    }

    //流水线的阶段
    stages{
        //阶段1 获取代码
        stage("CheckOut"){
            // environment{
            //     branchName = "test"
            // }
            steps{
                script{
                     echo "${branchName}"
                    //  echo "${version}"
                     echo "${VERSION}"
                     echo "${env.VERSION}"
                     echo "${params.VERSION}"
                }
            }
        }
        stage("Build"){
            steps{
                script{
                    println("运行构建")
                    echo "${branchName}"
                    // echo "${version}"
                }
            }
        }
        stage("deploy"){
            when{
                environment name: "branchName"value: "dev"
            }
            input {
                message '选择开发环境'
                ok '提交'
                parameters {
                    choice choices: ['dev''prod''test'], name: 'envName'
                }

            }
            steps{
                echo "deploy ${envName}"
            }

        }
    }
    post {
        always{
            script{
                println("流水线结束后,经常做的事情")
            }
        }

        success{
            script{
                println("流水线成功后,要做的事情")
            }

        }
        failure{
            script{
                println("流水线失败后,要做的事情")
            }
        }

        aborted{
            script{
                println("流水线取消后,要做的事情")
            }

        }
    }
}

这里的自己现象:自己现象为什么和老师的不一样呢。。。😥

image-20220420202358992
image-20220420202358992
image-20220420202435458
image-20220420202435458

老师现象:

image-20220420202304793
image-20220420202304793

10.parallel{}阶段并行

image-20220420202656159
image-20220420202656159

🍀 示例

我们先来给 master 节点打个master标签:

image-20220420203845288
image-20220420203845288

编写代码:

image-20220420204056637
image-20220420204056637
pipeline {
    agent any
    stages {
        stage('Parallel Stage') {
            failFast true
            parallel {
                stage('windows') {
                    agent {
                        label "master"
                    }
                    steps {
                        echo "windows"
                    }
                }
                stage('linux') {
                    agent {
                        label "build"
                    }
                    steps {
                        echo "linux"
                    }
                }
            }
        }
    }
}

构建:

image-20220420204021169
image-20220420204021169
image-20220420203954937
image-20220420203954937

关于我

我的博客主旨:我希望每一个人拿着我的博客都可以做出实验现象,先把实验做出来,然后再结合理论知识更深层次去理解技术点,这样学习起来才有乐趣和动力。并且,我的博客内容步骤是很完整的,也分享源码和实验用到的软件,希望能和大家一起共同进步!

各位小伙伴在实际操作过程中如有什么疑问,可随时联系本人免费帮您解决问题:

  1. 个人微信二维码:x2675263825 (舍得), qq:2675263825。

    image-20211002091450217
    image-20211002091450217
  2. 个人微信公众号:云原生架构师实战

    image-20211002141739664
    image-20211002141739664
  3. 个人博客地址:www.onlyonexl.cn

    image-20211002092057988
    image-20211002092057988
  4. 个人 csdn

    https://blog.csdn.net/weixin_39246554?spm=1010.2135.3001.5421

    image-20211002092344616
    image-20211002092344616
  5. 个人已开源干货 😘

    不服来怼:宇宙中最好用的云笔记 & 其他开源干货:https://www.yuque.com/go/doc/73723298?#

    image-20220423100718009
    image-20220423100718009

最后

好了,关于 Jenkins Pipeline 语法就到这里了,感谢大家阅读,最后贴上我女神的 photo,祝大家生活快乐,每天都过的有意义哦,我们下期见!

image-20220423100835738
image-20220423100835738

分类:

后端

标签:

后端

作者介绍

舍得
V1