Skip to content
SRE运维进阶之路SRE运维进阶之路
github icon
  • Jenkins

    • Jenkins 学习笔记
      • 1 Jenkins 简介

        • 1.1 DevOps、CI、CD都是什么鬼?
          • 1.2 Jenkins简介
          • 2 安装 Jenkins

            • 2.1 yum 安装 jenkins
              • 2.2 war 包安装 jenkins
                • 2.3 使用 ansible 安装 jenkins
                  • 2.4 使用docker安装jenkins
                  • 3 使用 Jenkins

                    • 3.1 Jenkins用户权限管理
                      • 3.2 访问 API
                      • 4 流水线核心语法

                        • 4.1 开始编写Jenkinsfile
                          • 为什么使用pipeline?
                            • pipeline定义
                              • pipeline演示
                                • 验证流水线效果
                                • 4.2 Jenkins流水线语法
                                  • 4.3 Groovy 简明教程
                                    • 4.4 Jenkins共享库应用
                                      • 4.5 共享库之钉钉消息推送
                                        • 4.6 流水线开发工具
                                          • 4.7 pipeline 生产配置实例
                                            • 4.8 在 VS Code 中校验 Jenkinsfile
                                            • 5 流水线集成篇

                                              • 5.1 构建发布工具集成
                                                • 5.2 用户认证系统集成
                                                • 6 管理 jenkins

                                                  • 6.1 Jenkins 关闭和重启的实现方式
                                                  • 7 日常维护

                                                    • 7.1 Jenkins Job迁移
                                                    • 8 Jenkins 常见问题
                                                    • Ansible

                                                      • Ansible 学习笔记
                                                        • 1 初识Ansible
                                                          • 2 Ansible Inventory配置详解
                                                            • 3 Ansible Ad-hoc命令集

                                                              • 3.1 Ansible Ad-hoc 常用命令集
                                                                • 3.2 Ansible lineinfile模块详解
                                                                • 4 Ansible Playbook

                                                                  • 4.1 Playbook的结构及handler用法
                                                                    • 4.2 Playbook循环语句
                                                                      • 4.3 Playbook条件语句
                                                                        • 4.4 Playbook高级用法
                                                                          • 4.5 Playbook之tags
                                                                            • 4.6 巧用Roles
                                                                              • 4.7 Jinja2 模板
                                                                                • 4.8 yaml语法
                                                                                • 5 Ansible变量

                                                                                  • 5.1 自定义变量
                                                                                    • 5.2 Fact变量
                                                                                      • 5.3 魔法变量
                                                                                        • 5.4 使用lookup生成变量
                                                                                          • 5.5 使用vault配置加密
                                                                                          • 6 Ansible使用优化
                                                                                            • 7 常见问题
                                                                                              • 8 综合项目

                                                                                                • 使用 ansible 快速安装 k8s 机器

                                                                                              4.1 开始编写Jenkinsfile

                                                                                              author iconClaycalendar icon2021年6月3日category icon
                                                                                              • 自动化工具
                                                                                              tag icon
                                                                                              • Jenkins
                                                                                              timer icon大约 3 分钟

                                                                                              此页内容
                                                                                              • 为什么使用pipeline?
                                                                                              • pipeline定义
                                                                                              • pipeline演示
                                                                                              • 验证流水线效果

                                                                                              # 4.1 开始编写Jenkinsfile

                                                                                              本文转自:开始编写 Jenkinsfile | 泽阳open in new window

                                                                                              您好,还在疑惑什么是流水线吗? 本章我们将告诉您如何运行一条流水线 赶快学习吧! 😀


                                                                                              # 为什么使用pipeline?

                                                                                              本质上,jenkins是一个自动化引擎,它支持许多自动模式。流水线向Jenkins添加了一组强大的工具,支持用例、简单的持续集成到全面的持续交付流水线。 通过对一系列的发布任务建立标准的模板,用户可以利用更多流水线的特性,比如:

                                                                                              • 代码化: 流水线是在代码中实现的,通常会存放到源代码控制,使团队具有编辑、审查和更新他们项目的交付流水线的能力。
                                                                                              • 耐用性:流水线可以从Jenkins的master节点重启后继续运行。
                                                                                              • 可暂停的:流水线可以由人功输入或批准继续执行流水线。
                                                                                              • 解决复杂发布: 支持复杂的交付流程。例如循环、并行执行。
                                                                                              • 可扩展性: 支持扩展DSL和其他插件集成。

                                                                                              构建一个可扩展是Jenkins的核心价值,流水线可以通过ShareLibrary的方式来扩展。

                                                                                              # pipeline定义

                                                                                              关于Jenkins流水线的运行我们可以抽象一下,例如:可以把流水线(pipeline)想象成13号线地铁,把流水线的阶段(stage)想象成地铁的每一个站点,把流水线脚本(jenkinsfile)想象成地铁线路图。这就是流水线的多样性,每条线路都有不同的站点。

                                                                                              imagesopen in new window

                                                                                              现在地铁(Jenkins)已经有了,我们需要设计地铁的运行线路图(Jenkinsfile),在线路图中指定要经过的站点(stages)。这下你是否已经知道我们要运行一条流水线,需要先做什么呢? –编写jenkinsfile

                                                                                              Pipeline

                                                                                              • Jenkins的Pipeline通过Jenkinsfile进行描述(类似于Dockerfile)
                                                                                              • Jenkinsfile是Jenkins的特性(pipeline as code)
                                                                                              • Pipeline是Jenkins的核心功能,提供一组可扩展的工具。
                                                                                              • 通过Pipeline 的DSL(Pipeline Domain Specific Language)语法可以完成从简单到复杂的交付流水线实现。

                                                                                              Jenkinsfile

                                                                                              • Jenkinsfile使用两种语法进行编写,分别是声明式和脚本式。
                                                                                              • 声明式和脚本式的流水线从根本上是不同的。
                                                                                              • 声明式是jenkins流水线更友好的特性。
                                                                                              • 脚本式的流水线语法,提供更丰富的语法特性。
                                                                                              • 声明式流水线使编写和读取流水线代码更容易设计。

                                                                                              # pipeline演示

                                                                                              来我们一起看下这里的配置,看下Jenkinsfile的组成及每个部分的功能含义。

                                                                                              • 使用agent{},指定node节点/workspace(定义好此流水线在某节点运行)
                                                                                              • 指定options{}运行选项(定义好此流水线运行时的一些选项,例如输出日志的时间)
                                                                                              • 指定stages{}(stages包含多个stage,stage包含steps。是流水线的每个步骤)
                                                                                              • 指定post{}(定义好此流水线运行成功或者失败后,根据状态做一些任务)
                                                                                              pipeline{
                                                                                                  //指定运行此流水线的节点
                                                                                                  agent { node { label "build"}}
                                                                                                  
                                                                                              
                                                                                                  //流水线的阶段
                                                                                                  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("流水线取消后,要做的事情")
                                                                                                          }
                                                                                                      
                                                                                                      }
                                                                                                  }
                                                                                              }
                                                                                              
                                                                                              1
                                                                                              2
                                                                                              3
                                                                                              4
                                                                                              5
                                                                                              6
                                                                                              7
                                                                                              8
                                                                                              9
                                                                                              10
                                                                                              11
                                                                                              12
                                                                                              13
                                                                                              14
                                                                                              15
                                                                                              16
                                                                                              17
                                                                                              18
                                                                                              19
                                                                                              20
                                                                                              21
                                                                                              22
                                                                                              23
                                                                                              24
                                                                                              25
                                                                                              26
                                                                                              27
                                                                                              28
                                                                                              29
                                                                                              30
                                                                                              31
                                                                                              32
                                                                                              33
                                                                                              34
                                                                                              35
                                                                                              36
                                                                                              37
                                                                                              38
                                                                                              39
                                                                                              40
                                                                                              41
                                                                                              42
                                                                                              43
                                                                                              44
                                                                                              45
                                                                                              46
                                                                                              47
                                                                                              48
                                                                                              49
                                                                                              50
                                                                                              51

                                                                                              # 验证流水线效果

                                                                                              查看Jenkins构建日志(正确效果)imagesopen in new window

                                                                                              通过BlueOcean查看(如果没有BlueOcean图标,需要自行在插件中心安装插件)imagesopen in new window

                                                                                              到此一个简单的Jenkinfile完成了! 后面我们来详细分析每个步骤的作用。

                                                                                              edit icon编辑此页open in new window
                                                                                              上次编辑于: 2022/4/27 15:33:00
                                                                                              贡献者: clay-wangzhi
                                                                                              下一页
                                                                                              4.2 Jenkins流水线语法
                                                                                              备案号:冀ICP备2021007336号
                                                                                              Copyright © 2023 Clay