jenkins基础

Jenkins介绍

持续集成，就是通常所说的CI（Continues Integration），可以说是现代软件技术开发的基础。
持续集成是一种软件开发实践，即团队开发成员经常集成他们的工作，通常每个成员至少集成一次，也意味着每天可能会发生多次集成。
每次集成都通过自动化的构建（包括编译，发布，自动化测试）来验证，从而尽快地发现集成错误。许多团队发现这个过程可以大大减少集成的问题，让团队能够更快的开发内聚的软件。
目的:
持续、自动地构建/测试软件项目。
监控软件开放流程，快速问题定位及处理，提示开放效率。

Jenkins的工作原理: 即是将源代码从gitlab上拷贝一份到本地,然后根据设置的脚本进行构建,一般则都是采用dockerfile的形式,进行本地打包构建测试.

Jenkins pipeline 总体介绍

pipeline是一套运行在jenkins上的工作流框架,将原本独立运行单个或者多个节点的任务链接起来,实现单个任务难以完成的复杂流程与可视化.
pipeline 是jenkins2.X 最核心的特性，帮助jenkins 实现从CI 到 CD与 DevOps的转变
pipeline 提供一组可扩展的工具，通过 pipeline domain specific language syntax 可以到达pipeline as code 目的

pipiline as code : jenkinsfile 存储在项目的源代码库

jenkins pipeline 入门
pipeline 支持两种语法

-　　Declarative 声明式

-　　Scripted pipeline 脚本式
pipline的五大特性:
在这里插入图片描述

pipeline基本结构

pipeline{
    agent any 
    stages{
        stage('build'){
            steps{
                echo 'hello steps'
            }
        }
    }
}

pipeline语法

其中最顶层的pipeline是必须要有的,
agent
用来指定pipeline的执行节点,一般放在顶层,支持几个不同参数:

any: 表示可以在任意节点或者代理上执行这个pipeline
none:表示表示不会为整个pipeline指定执行节点,需要每部分的stage指定
label: 在标签指定的可用代理上执行 pipeline 或 stage，比如 agent {label “label”} 表示流水线或者阶段可以运行在任何一个具有 label 标签的代理节点上。
自定义工作空间:代理节点的标签新增了一个特性，允许为流水线或阶段指定一个自定义的工作空间，用 customWorkspace 指令来指定。和 label 功能类似。
POST
post部分是用来指定pipeline或者stage执行完毕后执行的一些操作,比如发送邮件、环境清理等。post 部分在 Jenkins 代码中是可选的,可以方到顶层agent也可以在stage中,
always : 当pipeline执行完成后,必须要执行的动作,不管成功还是还失败
success: 当 pipeline 执行完毕后且构建结果为成功状态时才会执行的操作。
failure: 当 pipeline 执行完毕后且构建结果为失败时执行的操作，比如发送错误日志给相关人员
changed: 当 pipeline 执行完毕后且构建状态和之前不一致时执行的操作。
aborted: 当手动被停止
unstable: 构建不稳定时执行的操作

pipeline {
    agent any
    stages {
        stage ("Build") {
            bat "dir"
        }
    }
    post {
        always {
            script {
                echo "post always "
            }
        } 
        success{
            script {
                echo "post success"
            }
        } 
        failure{
            script {
                echo "post failure"
            }
        }
    }
}

stages/stage/steps
stages: 是单个阶段的操作封住到stages中,stages中可以有多个stage
stage : 一个单独的阶段,实际上所有实际工作都将包含在一个或多个 stage 指令中。stage{…} 里面有一个强制的字符串参数，用来描述这个 stage 的作用，这个字符串参数是不支持变量的，只能你自己取名一个描述字段。
steps: 一个stage下至少有一个steps,可以在 steps 下写调用一个或者几个方法，也就是两三行代码。
注意:
在声明式中,有且仅有一个stages,
一个 stage{…} 必须有且只有一个 steps{…}, 或者 parallel{…} 或者 stages {…}，多层嵌套只支持在最后一个 stage{…} 里面。
在声明式语法中只支持 steps，不支持在 steps {…} 里面嵌套写 step{…}。

pipeline {
    agent any 
    stages {
        stage('build') {
            steps {echo 'build'}
        }
        stage ('test'){
            steps {echo "${JAVA_HOME}"
            }
        }
    }
}

environment
作用就是通过键值对的方式,定义整个脚本使用的环境变量

pipeline {
    agent any
    environment {
        test = true
    } 
    stages {
        stage('build') {
            steps {
                script{
                    if(test == true) {
                    // 一些特定的操作
                        echo 'sucess'
                    }
                }
            }
        }
    }
}

options
options指令在pipeline中是可选的,用来指定一些属性和值,这些预定义的的选项可以应用到整个脚本中,

retry: 表示Jenkins中的job执行失败后继续进行几次尝试,可以放到顶层pipeline中也可以放到stage中,
```
options {
 retry(3)
}
```
buildDiscarder: 保留指定数量的流水线的执行,包含控制台的输出. 会在工作空间中保存制品和执行日志，如果执行次数太多的会话，这些内容会占用很多的存储空间，使用该参数后会只保留最近指定次数的构建结果，自动清理之前的内容。
checkoutToSubdirectory 作用：指定检出到工作空间的子目录中。Jenkins 从代码管理库中拉取代码时默认检出到工作空间的根目录，如果想修改的话可以用此参数。
disableConcurrentBuilds: 用来阻止脚本同时执行多个
timeout: 为流水线设置一个超时时间,

    pipeline {
    agent any
    options {
        timeout(time:10, unit:'HOURS')
    }
    stages {
        stage('test') {
            steps {
                // 步骤
            }
        }
    }
}

skipDefaultCheckout 作用：删除隐式的 checkout scm 语句，因此可以从 Jenkinsfile 定义的流水线中跳过自动的源码检出功能

parameters

parameters用来在pipeline中实现参数化构建,也就是根据用户指定的不同的操作,pipeline支持很多种类型的参数,有字符串参数，布尔选择参数，下拉多选参数等。

字符串参数开始构建前需要用户输入字符串，比如 ip 或者 url。

pipeline {
    agent any
    parameters {
        string(name: 'DEPLOY_ENV', defaultValue: 'release', description: '')
    }
}

布尔值参数
作用：定义一个布尔类型参数，在执行构建前用户在 Jenkins UI 上选择是还是否，选择是执行这部分代码，否则会跳过这部分。比如：执行完毕后环境的清理工作。
pipeline {
agent any
parameters {
booleanParam(name: ‘DEBUG_BUILD’,defaultValue: true, description: ‘’)
}
}
文本参数
支持写很多行的字符串:
pipeline {
agent any
parameters {
text {name:‘Welcome_text’, defaultValue: ‘One\nTwo\nThree\n’,description: ‘’ }
}
}
选择参数
作用：支持用户从多个选择项中选择一个值用来表示这个变量的值。比如：选择服务器类型、选择版本号等
pipeline {
agent any
parameters {
choice (name: ‘ENV_TYPE’, choices: [‘test’, ‘dev’, ‘product’], description:‘testmeans test env,….’)
}
}
文件参数
参数化构建 UI 上提供一个文件路径的输入框，Jenkins 会自动去根据用户提供的网络路径去查找并下载
pipeline {
agent any
parameters {
name: ‘FILE’, description: ‘Some file to upload’)
}
}
密码参数
密码（password）参数就是在 Jenkins 参数化构建 UI 提供一个暗文密码输入框。需要登录到服务器做自动化操作，为了安全起见，
pipeline {
agent any
parameters {
password(name: ‘PASSWORD’, defaultValue: ‘test’, description: ‘A secret password’)
}
}

tool

定义自动安装和放置工具的路径。
对于 agent none，这个关键字将被忽略，因为没有任何节点或者代理可以用来安装工具。此指令主要是为了三大工具（jdk、gradle、maven）提供环境变量服务。一旦配置完成，tools 指令可以让我们指定的工具需要在我们已经选择的代理节点上自动安装在配置路径下。
pipeline {
agent any
tools {
jdk ‘jdk1.8’
}
stages {
stage(‘test’) {
steps {
sh ‘java -version’
}
}
}
}
左侧的 jdk 是流水线模型中定义的特殊字符串，目前，在声明式流水线中可以指定的合法的工具类型如下：ant、git、gradle、jdk、maven、jgit 等。

右侧的 jdk8 映射的是全局工具配置中的名称字段（管理 Jenkins → Global ToolConfiguration 中预配置）。例如，上面代码我写了 jdk1.8，那么必须在 Jenkins 管理–>全局工具配置中有别名为 jdk1.8 配置。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hXOjqAUI-1668744102908)(./images/2022-11-16-18-43-27.png)]

一旦这样设置后，jdk 工具会被自动安装到指定的路径下，然后我们可以在流水线步骤中简单的使用 jdk1.8 字符串替代 JAVA_HOME 路径，Jenkins 会把它映射到我们系统中安装的 JDK。
pipeline{
agent any
parameters {
string(name: ‘gradleTool’, defaultValue: ‘gradle3’, description: ‘gradle version’)
}
tools{
gradle “${params.gradleTool}”
}
}
说明：如果需要输入一个特定的版本来使用，这个 tools 指令可以使用一个参数的值。
注意：当前生命式语法有一个局限就是当这个流水线第一次运行时，Jenkins 不能识别出该构建需要一个参数，需要先手动构建一次。

when

when{…}是写在stage{}里面一条控制,允许pipeline根据给定的条件来决定是否执行某个阶段,when指令必须至少包含一个条件,也可以包含多个条件,这和子条件嵌套在一个allof条件中一样.

更复杂的条件结构可使用嵌套条件建：not，allOf 或 anyOf，嵌套条件可以嵌套到任意深度。

branch
当前正在构建的分支,与给出的分支模式匹配时执行,适用于多分支结构
when {branch ‘master’}
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’ } }
buildingTag
如果 pipeline 所执行的暧昧被打了 tag 则执行。
when { buildingTag() }
测试代码:

pipeline{
    agent any 
    environment {
        quick_test = false 
    }
    <!-- 单个操作的阶段, -->
    stages {
            stage('Examplie build'){
                <!-- 单个构建阶段 -->
                steps {
                    <!-- 具体执行阶段,执行具体的方法 -->
                    script { 
                        <!--  -->
                        echo "hello world"
                    }
                }

            },
            stage('Example Deploy'){
                when {
                    expression {
                        <!-- 表示当给定的Groovy 表达式返回 true 时执行。 -->
                        return (quick_test == 'true')
                    }
                }
                steps {
                    <!-- 被执行 -->
                    echo "Deploy"
                }
            }
    },
}
script
作用：用来在声明式流水线中写非声明式代码的地方，允许你定义一定代码块/闭包用来囊括非声明式的语法，其实就是在 script 中写 Groovy 代码。比如 if...else 等语句。

tiggers
用来指定使用什么类型的触发器来自动启动流水线的构建,
注意: 这些触发器不适用与多分支的流水线,github组织类任务,

cron: 按照指定的周期规律执行流水线,与crontab类似

triggers {
    cron ('0 0 0 * * ')
}

upstream 由上游的任务构建完毕后才会触发本任务的执行,

triggers {
    upsteam threshold: 'UNSTABLE',upstreamProjects : 'jobA,jobB'
}
说明: upstreamProjects: 指定上游任务的名称,有多个任务时用逗号分隔. 
threshold: 指定上游的执行结果是什么值的时候进行触发,
    1,success: 
    2,unstable: 存在失误但不至于构建失败
    3,failuer: 构建失败.

pollSCM: 轮询代码仓库,定期访问仓库代码是否有更新,有变化就执行,但但是在一定的构建时间内，如果有多次代码提交，当构建失败时无法马上知道是哪一次的提交导致的，所以这个指令不是很常用，所以一般用webhook,当有代码提交的时候主动通知到 Jenkins。

parallel

声明性管道中的阶段可能只有一个parallel部分,其中包含要并行运行的嵌套阶段的列表,需要注意的是一个阶段都必须有且只有一个 steps，stages，parallel，或matrix。,
这里是不可能进行嵌套的parallel或matrix块内,stage ,如果该指令,stage指令嵌套在一个parapllel 或matrix阻塞本身,然后,stage一个内指令,parallel或matrix 块可以使用的所有其他的功能stage,包括: agent tools,when等.

pipeline {
    agent any
    stages {
        stage('Non-Parallel Stage') {
            steps {
                echo 'This stage will be executed first.'
            }
        }
        stage('Parallel Stage') {
            when {
                branch 'master'
            }
            failFast true
            parallel {
                stage('Branch A') {
                    agent {
                        label "for-branch-a"
                    }
                    steps {
                        echo "On Branch A"
                    }
                }
                stage('Branch B') {
                    agent {
                        label "for-branch-b"
                    }
                    steps {
                        echo "On Branch B"
                    }
                }
                stage('Branch C') {
                    agent {
                        label "for-branch-c"
                    }
                    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"
                            }
                        }
                    }
                }
            }
        }
    }
}

此外,可以在parallel阶段,对于他们中任何一个发生故障的情况下,将所有都进行终止,加入选项: failFast true 到stage 含有 parallel中,添加的另一个选项 failfast是在管道定义中添加一个选项: parallelsAlwaysFailFast()

pipeline {
    agent any
    options {
        parallelsAlwaysFailFast()
    }
    stages {
        stage('Non-Parallel Stage') {
            steps {
                echo 'This stage will be executed first.'
            }
        }
        stage('Parallel Stage') {
            when {
                branch 'master'
            }
            parallel {
                stage('Branch A') {
                    agent {
                        label "for-branch-a"
                    }
                    steps {
                        echo "On Branch A"
                    }
                }
                stage('Branch B') {
                    agent {
                        label "for-branch-b"
                    }
                    steps {
                        echo "On Branch B"
                    }
                }
                stage('Branch C') {
                    agent {
                        label "for-branch-c"
                    }
                    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"
                            }
                        }
                    }
                }
            }
        }
    }
}

pipeline中获取shell命令的标准输出或者状态

获取标准输出

result = sh resturnStdout: true,script: "shell cmd"
result =result.trim()
//简单写法
result = sh(script: "<shell command>", returnStdout: true).trim()

获取执行状态

result = sh(script: "<shell command>", returnStatus: true).trim()

pipeline对git的操作

通过jenkins的pipeline方式从远程的git仓库上拉取脚本执行,需要的参数,拉取的分支,拉取的位置,以及代码保存的位置

<!-- 代码段 -->
git {
     branch: "master",
     credentialsID: "/root",
     url :'git地址',

}

pipeline内置基础

文件目录相关步骤

deleteDir: 删除当前目录,
dir 切换到目录,
fileExists :判断指定的文件是否存在, fileExists(‘/tmp/a.jar’)判断/tmp/a.jar文件是否存在,可以判断相对路径,结果是布尔型,
isUnix: 判断是否为unix系统,
pwd 确认当前目录,
writeFile 将内容写入指定文件中. 支持file,text,encoding
readFile 读取指定文件,以文本形式返回,参数: file, encodeing

可以在pipeline中定义相关函数,定义方式与Python定义方式类似.

参考链接:
https://www.cnblogs.com/ssgeek/p/12856067.html
https://www.cnblogs.com/juno3550/p/14693530.html#base