Jenkins

1、安装

1.1 环境准备

1.1.1 jdk环境

apt search jdk
apt update 
apt install openjdk-11-jdk

1.2 安装

# 下载war包
https://mirrors.tuna.tsinghua.edu.cn/jenkins/war-stable/2.426.2/jenkins.war
32bf8d53dfbe4cdaa3fbbee4e6a5f506
# 初始化设置替换插件源为国内源
sed -ir 's#https:\/\/updates.jenkins.io\/download#https:\/\/mirrors.tuna.tsinghua.edu.cn\/jenkins#g' default.json && sed -ir 's#https:\/\/www.google.com#https:\/\/www.baidu.com#g' default.json

1.3 插件安装

# 若初始化没有安装插件推荐手动安装下列插件
https://cloud.tencent.com/developer/article/2188284
Folders
OWASP Markup Formatter
Build Timeout 
Credentials Binding
Timestamper
Workspace Cleanup
Ant
Pipeline
Pipeline Graph Analysis 
Pipeline: API
Pipeline: Basic Steps
Pipeline: Declarative ...
Git
SSH Build Agents
Matrix Authorization Strategy 
Email Extension
Mailer
Environment Injector 
PAM Authentication
Build Environment 
GitLab
build user vars
DingTalk
NodeJs 
Job Configuration History
Build Name and Description Setter
Display Console Output 
Active Choices
Git parameter
Blue Ocean 
docker 
docker pipeline
kubernetes

1.4 代理节点添加

1.4.1 node节点添加

1、安装java环境
apt update  && apt install openjdk-11-jdk
2、配置
指定工作目录
指定一个或多个lable，可以根据lable进行调度，多个lable用空格分开
添加一个ssh-key并应用

1.4.2 kubernetes节点添加

# kubernetes地址
cat  kubeconfig|grep server
# kubernets服务证书key
cat kubeconfig|grep client-key-data|base64 -d
# 凭据生成
cat kubeconfig|grep certificate-authority-data|base64 -d > ca.crt
cat kubeconfig|grep client-certificate-data|base64 -d > 1.crt
cat kubeconfig|grep client-key-data|base64 -d >1.key
openssl pkcs12 -export -out ./cert.pfx -inkey ./1.key -in ./1.crt -certfile  ./ca.crt 
输入自定义密码确认，将生成的文件上传生成新的凭据
使用生成的凭据并进行测试

2、pipeline

2.1 凭据管理

可以选择新加域或直接添加凭据

类型可以选择秘钥类型
	账户名密码
	sshkey
	gitlabtoken等
id 是一个在jenkins显示的名称
描述是针对这个凭据的说明

2.2 pipeline

2.2.1 概念

2.2.1.1 pipeline

实现cd的自动化流程，由多个步骤构成

2.2.1.2 node

可以理解为jenkins的slave节点，jenkins将任务分派给node节点进行执行，逻辑上是一个独立的机器

2.2.1.3 stage

步骤，一组动作的集合，对要执行的动作进行抽象分类，属于同一类下的动作的集合

2.2.1.4 step

阶段，步骤里的每一步

2.2.2 语法分类

2.2.2.1 声明式

# 采用 Groovy 语法
例
pipeline {  # 标准格式
    agent any # 指定运行此pipeline的node可以是任意代理
    stages {	# 标准格式
        stage('Build') { # 定义一个步骤，名称为build 
            steps { # 定义一个阶段 
                sh 'make' # 阶段需要做的事
            }
        }
        stage('Test'){
            steps {
                sh 'make check'
                junit 'reports/**/*.xml' 
            }
        }
        stage('Deploy') {
            steps {
                sh 'make publish'
            }
        }
    }
}

2.2.2.2 脚本式

node {  
    stage('Build') { 
        // 
    }
    stage('Test') { 
        // 
    }
    stage('Deploy') { 
        // 
    }
}

2.2.3 构建

2.2.3.1 经典ui

# 通过自己书写pipeline代码进行构建

2.2.3.2 blue ocean

使用白屏化的方式进行构建

2.2.3.3 使用git等源码管理

# 将书写的pipeline上传git通过git来进行构建

gitlab创建一个测试用的项目
将其clone到本地，并生成Jenkinsfile并上传

在使用经典ui进行构建时选择使用from scm
新建一个凭据，使用账号密码或者token

测试

2.2.3.4 模版参考

# 流水线语法可以根据片段生成模版

2.3 pipeline语法

参考链接
https://www.jenkins.io/zh/doc/book/pipeline/syntax/

2.3.1 格式

# 1、由一个块包括其他stages，steps，指令等组成
pipeline {
    
}
# 2、字段自检不需要加分隔符，每条语句在自己的行

2.3.2 agent

# 必须指定可以定义在顶层或其余阶段中
agent 参数
	any 在任何可用代理执行
	none 若顶层不定义那么每个阶段都需要定义自己的agent
	label 针对代理节点的label进行筛选
		agent { label 'my-defined-label' }
	node 和lable类似，但可以允许有额外选项
	docker 使用指定容器进行执行，容器运行在默认node，可以使用lable进行主机匹配
		agent {
            docker {
                image 'maven:3-alpine'
                label 'my-defined-label'
                args  '-v /tmp:/tmp'
            }
        }
    dockerfile 指定一个容器，但容器从dockerfile生成
    	agent {
            // Equivalent to "docker build -f Dockerfile.build --build-arg version=1.0.2 ./build/
            dockerfile {
                filename 'Dockerfile.build'
                dir 'build'
                label 'my-defined-label'
                additionalBuildArgs  '--build-arg version=1.0.2'
            }
        }

2.3.2.1 node节点

pipeline {
    agent {
      label 'slave1'
    }

    stages {
        stage('Test') {
            steps {
                sh 'hostname'
            }
        }
    }
}

2.3.2.2 docker

pipeline {
    agent {
      docker{
        image 'quanheng.com/k8s/alpine:v2'
        label 'slave1'
      }
    }

    stages {
        stage('Test') {
            steps {
                sh 'hostname -i'
            }
        }
    }
}

2.3.2.3 dockerfile

pipeline {
    agent {
      dockerfile {
        filename 'Dockerfile'
        dir './dockerfile/alpine'
        label 'slave1'
        additionalBuildArgs  '--build-arg version=v3'
        }
    }

    stages {
        stage('Test') {
            steps {
                sh 'hostname -i'
            }
        }
    }
}

2.3.3 post

# 定义一个或者多个step 针对pipeline的执行状态进行处理，post可以定义多个，根据不同的执行情况来触发不同结果，类似编程语言中的 Switch 和 select
参数
	always 无论流水线或阶段的完成状态如何，都允许在 post 部分运行该步骤。
	changed 只有当前流水线或阶段的完成状态与它之前的运行不同时，才允许在 post 部分运行该步骤。
	failure 只有当前流水线或阶段的完成状态为"failure"，才允许在 post 部分运行该步骤, 通常web UI是红色。
	success	只有当前流水线或阶段的完成状态为"success"，才允许在 post 部分运行该步骤, 通常web UI是蓝色或绿色。
	unstable 只有当前流水线或阶段的完成状态为"unstable"，才允许在 post 部分运行该步骤, 通常由于测试失败,代码违规等造成。通常web UI是黄色。
	aborted	只有当前流水线或阶段的完成状态为"aborted"，才允许在 post 部分运行该步骤, 通常由于流水线被手动的aborted。通常web UI是灰色。
例子
pipeline {
    agent any
    stages {
        stage('Example') {
            steps {
                echo 'Hello World'
            }
        }
    }
    post { 
        always { 
            echo 'I will always say Hello again!'
        }
    }
}

2.3.3.1 例

# 可以定义在stage和step
pipeline {
    agent {
      dockerfile {
        filename 'Dockerfile'
        dir './dockerfile/alpine'
        label 'slave1'
        additionalBuildArgs  '--build-arg version=v3'
        }
    }

    stages {
        stage('Test') {
            steps {
                sh 'hostname -i'
            }
            post{
                always{
                    echo "====++++always++++===="
                }
                success{
                    echo "====++++only when successful++++===="
                }
                failure{
                    echo "====++++only when failed++++===="
                }
            }
        }
    }
    post { 
        always { 
            echo 'always'
        }
        success { 
            echo 'success'
        }
        failure { 
            echo 'failure'
        }
        unstable { 
            echo 'unstable'
        }
        changed { 
            echo 'changed'
        }
    }
}

2.3.4 stages

# 阶段，包含一个或多个stage，必须指定
例
pipeline {
    agent any
    stages { 
        stage('Example') {
            steps {
                echo 'Hello World'
            }
        }
    }
}

2.3.5 steps

# 步骤，要执行的具体步骤，必须指定
例
pipeline {
    agent any
    stages {
        stage('Example') {
            steps { 
                echo 'Hello World'
            }
        }
    }
}

2.3.6 environment

# 声明环境变量，根据所在位置决定作用域
credentials() # 此方法可以使用定义的秘钥凭据
pipeline {
    agent any
    environment {  # 全局变量
        CC = 'clang'
    }
    stages {
        stage('Example') {
            environment {  # 仅针对当前步骤的变量
                AN_ACCESS_KEY = credentials('my-prefined-secret-text') 
            }
            steps {
                sh 'printenv'
            }
        }
    }
}

2.3.6.1 静态变量

# 和编程语言基本保持一致 变量查找一层层往外
pipeline {
    agent {
      dockerfile {
        filename 'Dockerfile'
        dir './dockerfile/alpine'
        label 'slave1'
        additionalBuildArgs  '--build-arg version=v3'
        }
    }
    environment {
        name = 'Global-name'
        value = 'Global-value'
    }
    stages {
        stage('Test') {
            environment {
                value = 'Test-value'
            }
            steps {
                sh 'echo $name'
                sh 'echo $value'
            }
        }
    }
}

2.3.6.2 动态变量

# 必须指定agent，否则将运行失败
pipeline {
    agent {
      label 'slave1'
    }
    environment {
        // 使用 returnStdout
        CC = """${sh(
                returnStdout: true,
                script: 'echo "hello world"'
            )}""" 
        // 使用 returnStatus
        EXIT_STATUS = """${sh(
                returnStatus: true,
                script: 'exit 1'
            )}"""
    }
    stages {
        stage('Test') {
            steps {
                sh 'echo $CC'
                sh 'echo $EXIT_STATUS'
            }
        }
    }
}

2.3.6.3 环境变量

pipeline {
    agent {
      label 'slave1'
    }
    stages {
        stage('TEST') {
            steps {
                sh 'printenv'
            }
        }
    }
}

# 环境变量可以直接引用
gitlabSourceRepoURL=git@172.31.3.155:guquanheng/jenkins.git
JENKINS_HOME=/root/.jenkins
GIT_PREVIOUS_SUCCESSFUL_COMMIT=a32a4df7cb4688ddb917a059d5626a32117ff38d
MAIL=/var/mail/root
SSH_CLIENT=172.31.3.39 36689 22
USER=root
CI=true
RUN_CHANGES_DISPLAY_URL=http://172.31.3.39:8080/job/git-sonar/39/display/redirect?page=changes
gitlabAfter=c82a258f7b625c1a62799f2f19da195919547df7
SHLVL=1
NODE_LABELS=slave1 jenkins-slave1
HUDSON_URL=http://172.31.3.39:8080/
GIT_COMMIT=c82a258f7b625c1a62799f2f19da195919547df7
OLDPWD=/root
HOME=/root
BUILD_URL=http://172.31.3.39:8080/job/git-sonar/39/
HUDSON_COOKIE=fe5e3321-5ef4-43c4-bce5-96cc387375d4
gitlabTargetBranch=main
JENKINS_SERVER_COOKIE=durable-714ab4663b2e12096cddf02acc8b836328b091d817856946b79fc80e87c04a7b
DBUS_SESSION_BUS_ADDRESS=unix:path=/run/user/0/bus
gitlabSourceRepoHttpUrl=http://172.31.3.155/guquanheng/jenkins.git
gitlabUserUsername=guquanheng
WORKSPACE=/jenkins/workspace/git-sonar
gitlabMergeRequestLastCommit=c82a258f7b625c1a62799f2f19da195919547df7
LOGNAME=root
NODE_NAME=jenkins-slave1
gitlabSourceRepoSshUrl=git@172.31.3.155:guquanheng/jenkins.git
_=/usr/bin/java
RUN_ARTIFACTS_DISPLAY_URL=http://172.31.3.39:8080/job/git-sonar/39/display/redirect?page=artifacts
STAGE_NAME=TEST
GIT_BRANCH=origin/main
gitlabSourceRepoHomepage=http://172.31.3.155/guquanheng/jenkins
EXECUTOR_NUMBER=0
gitlabBranch=main
XDG_SESSION_ID=10
RUN_TESTS_DISPLAY_URL=http://172.31.3.39:8080/job/git-sonar/39/display/redirect?page=tests
BUILD_DISPLAY_NAME=#39
gitlabSourceBranch=main
HUDSON_HOME=/root/.jenkins
JOB_BASE_NAME=git-sonar
PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games:/snap/bin
BUILD_ID=39
XDG_RUNTIME_DIR=/run/user/0
gitlabBefore=72b48bb3f7a8a698eca25debf6078b91f74fce9b
BUILD_TAG=jenkins-git-sonar-39
gitlabActionType=PUSH
JENKINS_URL=http://172.31.3.39:8080/
LANG=en_US.UTF-8
JOB_URL=http://172.31.3.39:8080/job/git-sonar/
gitlabSourceRepoName=jenkins
GIT_URL=http://172.31.3.155/guquanheng/jenkins
gitlabSourceNamespace=guquanheng
BUILD_NUMBER=39
JENKINS_NODE_COOKIE=221d0c8a-9230-4959-8824-d854250c047d
SHELL=/bin/bash
RUN_DISPLAY_URL=http://172.31.3.39:8080/job/git-sonar/39/display/redirect
HUDSON_SERVER_COOKIE=98a6aab0b5e53c04
JOB_DISPLAY_URL=http://172.31.3.39:8080/job/git-sonar/display/redirect
JOB_NAME=git-sonar
PWD=/jenkins/workspace/git-sonar
gitlabUserName=guquanheng
SSH_CONNECTION=172.31.3.39 36689 172.31.3.40 22
GIT_PREVIOUS_COMMIT=e041d20926de4520ff7abede6f99273c9de195b7
WORKSPACE_TMP=/jenkins/workspace/git-sonar@tmp
GITLAB_OBJECT_KIND=none

2.3.7 options

# 从流水线内部配置特定于流水线的选项
buildDiscarder 
为最近的流水线运行的特定数量保存组件和控制台输出。
例如: 
	options { buildDiscarder(logRotator(numToKeepStr: '1')) }

disableConcurrentBuilds
不允许同时执行流水线。 可被用来防止同时访问共享资源等。 
例如: 
	options { disableConcurrentBuilds() }

overrideIndexTriggers
允许覆盖分支索引触发器的默认处理。 如果分支索引触发器在多分支或组织标签中禁用, options { overrideIndexTriggers(true) } 将只允许它们用于促工作。否则, options { overrideIndexTriggers(false) } 只会禁用改作业的分支索引触发器。

skipDefaultCheckout
在`agent` 指令中，跳过从源代码控制中检出代码的默认情况。
例如: 
	options { skipDefaultCheckout() }

skipStagesAfterUnstable
一旦构建状态变得UNSTABLE，跳过该阶段。
例如: 
	options { skipStagesAfterUnstable() }

checkoutToSubdirectory
在工作空间的子目录中自动地执行源代码控制检出。
例如: 
	options { checkoutToSubdirectory('foo') }

timeout
设置流水线运行的超时时间, 在此之后，Jenkins将中止流水线。
例如: 
	options { timeout(time: 1, unit: 'HOURS') }

retry
在失败时, 重新尝试整个流水线的指定次数。 
例如: o
	ptions { retry(3) }

timestamps
所有由流水线生成的控制台输出，与该流水线发出的时间一致。 
例如: 
	options { timestamps() }

##################################################################################
pipeline {
    agent any
    options { # 相当于白屏配置超时时间
        timeout(time: 1, unit: 'HOURS') 
    }
    stages {
        stage('Example') {
            steps {
                echo 'Hello World'
            }
        }
    }
}

2.3.8 parameters

# 定义流水线要使用的参数，白屏使用参数化构建来创建
pipeline {
    agent any
    parameters { # 定义，允许有默认值和参数描述，类似argparser定义方式
        string(name: 'PERSON', defaultValue: 'Mr Jenkins', description: 'Who should I say hello to?')
    }
    stages {
        stage('Example') {
            steps {
                echo "Hello ${params.PERSON}" # 使用参数，注意参数引用只能使用双引号
            }
        }
    }
}

2.3.8.1 例

pipeline {
    agent {
      label 'slave1'
    }
    parameters {
        string(name: 'Greeting', defaultValue: 'Hello', description: 'How should I greet the world?')
    }
    stages {
        stage('TEST') {
            steps {
                echo "${params.Greeting} World!"
            }
        }
    }
}

2.3.9 triggers

# 触发器，当满足什么条件时执行pipeline
选项
	cron 定时
	pollSCM 和cron类似但存在源码检测机制，若代码被更改那么就会重新触发  只在Jenkins 2.22 及以上版本中可用。
	upstream 接受逗号分隔的工作字符串和阈值。 当字符串中的任何作业以最小阈值结束时，流水线被重新触发
		triggers { upstream(upstreamProjects: 'job1,job2', threshold: hudson.model.Result.SUCCESS) }

2.3.10 input

# 一个可交互的选项，根据定义的参数和用户输入匹配满足条件，那么可以使用定义的环境变量
例
pipeline {
    agent any
    stages {
        stage('Example') {
            input {
                message "Should we continue?" # 必须指定
                [id] #可选，默认为stage名称
                ok "Yes, we should." # 点击ok的文本
                submitter "alice,bob" # 允许哪些用户提交
                parameters {
                    string(name: 'PERSON', defaultValue: 'Mr Jenkins', description: 'Who should I say hello to?')
                }
            }
            steps {
                echo "Hello, ${PERSON}, nice to meet you."
            }
        }
    }
}

2.3.11 when

# 条件判断，当满足定义条件时执行，类似于编程语言的if  在进入 stage 的 agent 前评估 when
选项
	branch 当正在构建的分支与模式给定的分支匹配时，执行这个阶段, 例如: when { branch 'master' }。注意，这只适用于多分支流水线。
    environment 当指定的环境变量是给定的值时，执行这个步骤, 例如: when { environment name: 'DEPLOY_TO', value: 'production' }
    expression 当指定的Groovy表达式评估为true时，执行这个阶段, 例如: when { expression { return params.DEBUG_BUILD } }
    not 当嵌套条件是错误时，执行这个阶段,必须包含一个条件，例如: when { not { branch 'master' } }
    allOf 逻辑与 当所有的嵌套条件都正确时，执行这个阶段,必须包含至少一个条件，例如: when { allOf { branch 'master'; environment name: 'DEPLOY_TO', value: 'production' } }
    anyOf 逻辑或 当至少有一个嵌套条件为真时，执行这个阶段,必须包含至少一个条件，例如: when { anyOf { branch 'master'; branch 'staging' } }

2.3.12 parallel

# 并行执行，定义在stage之内，需要指定agent，以使他们分散开进行执行，提高效率
pipeline {
   agent any
   stages {
       stage('Stage1') {
           agent any
           steps {
              sh 'hostname;date'
              timestamps {
                echo '这是第一个被执行的 stage.'
                sleep 10
              }
           }
       }
       stage('并行执行的 Stage') {
           parallel {
               stage('Stage2.1') {
                   agent { label "slave1" }
                   steps {
                      sh 'hostname;date'
                      timestamps {
                        echo "在 agent slave1 上执行的并行任务 1."
                        sleep 10
                        echo "在 agent slave1 上执行的并行任务 1 结束."
                      }
                   }
               }
               stage('Stage2.2') {
                   agent any
                   steps {
                      sh 'hostname;date'
                      timestamps {
                        echo "在 agent master 上执行的并行任务 2."
                        sleep 5
                        echo "在 agent master 上执行的并行任务 2 结束."
                      }
                   }
               }
           }
       }
       stage('Stage3') {
           agent { label "slave1" }
           steps {
              sh 'hostname;date'
              timestamps {
                echo '这是最后一个被执行的 stage.'
                sleep 10
              }
           }
       }
   }
}

2.3.13 秘钥处理

# 可以将Secret 文本，带密码的用户名，Secret 文件通过定义的方法进行解析

2.3.13.1 secret

pipeline {
    agent {
      label 'slave1'
    }
    environment {
        K8S_ACCESS_KEY_ID=credentials('secret1') # 解析secret文本，可以直接调用
    }
    stages {
        stage('TEST') {
            steps {
                sh 'echo $K8S_ACCESS_KEY_ID' # 以加密形式显示
            }
        }
    }
}

2.3.13.2 用户名和密码

pipeline {
    agent {
      label 'slave1'
    }
    environment {
        BITBUCKET_COMMON_CREDS = credentials('gitlab1')
        BITBUCKET_COMMON_CREDS_USR = credentials('gitlab1')
        BITBUCKET_COMMON_CREDS_PSW = credentials('gitlab1')
    }
    stages {
        stage('TEST') {
            steps {
                sh 'echo $BITBUCKET_COMMON_CREDS_USR' # 用户名-明文
                sh 'echo $BITBUCKET_COMMON_CREDS_PSW' # 密码-密文
                sh 'echo $BITBUCKET_COMMON_CREDS' # username:password-密文
            }
        }
    }
}

2.4 tools配置

tool相当于各代理节点上的各种工具组件，比如mvn，docker，git等命令，将不同版本的命令定义为不同的tool名称，可以方便调用

3、使用

3.1 实现ci

目标：上传代码后可以进行拉取代码，代码测试，代码打包，代码上传到私有仓库
插件使用：gitlab，sonarqube，harbor

3.1.1 代码拉取

3.1.1.1 配置agent的ssh秘钥

gitlab配置

3.1.1.2 配置jenkins

3.1.1.2 测试

3.1.2 代码扫描

通过scannercli进行扫描将其结果上传到server端

架构

3.1.2.1 配置sonarqube

3.1.2.2 配置gitlab

# 安装 GitLab Branch Source 插件
# 配置gitlab

3.1.2.3 生成webhook

# 创建一个pipeline
# 记录webhook地址和生成的token

从gitlab生成webhook，填写上面的地址和token

3.1.2.4 生成sonar-scanner tool

3.1.2.5 测试

# 在项目下生成两个文件
# jenkinsfile
node {
  stage('SCM') {
    checkout scm
  }
  stage('SonarQube Analysis') {
    def scannerHome = tool 'sonar-scanner';
    withSonarQubeEnv() {
      sh "${scannerHome}/bin/sonar-scanner"
    }
  }
}
# sonar-project.properties
sonar.projectKey=git-sonar
当触发push时可以看到触发扫描

3.1.3 代码打包

3.1.3.1 docker

stage('Build') {
    def customImage = docker.build("quanheng.com/k8s/nginx:1.25"[,"./dockerfiles/test"]) # 第二参可以指定一个目录，改变dockerfile的路径
    customImage.push() # push方法将镜像上传到镜像仓库
    }

3.1.3.2 mvn

pipeline {
    agent { 
        docker {
            image 'quanheng.com/pub/maven:3.3.3'
            args '-v /root/.jenkins/workspace/maven/settings.xml:/usr/share/maven/conf/settings.xml' 
        }
    }
    stages {
        stage('build') {
            steps {
                sh 'mvn clean package -Dmaven.test.skip=true'           
            }
        }
    }
}

3.2 实现cd

3.2.1 使用jenkins实现cd

3.2.1.1 依赖

# 插件依赖
Git： Jenkins 安装中默认安装 Git 插件，所以不需要单独安装。利用 git 工具可以将 github、gitlab 等等的地址下载源码。
Docker： Jenkins 安装中默认安装 Docker 插件，所以不需要单独安装。利用 Docker 插件可以设置 Docker 环境，运行 Docker 命令，配置远程 Docker 仓库凭据等。
Kubernetes： Kubernetes 插件的目的是能够使用 Kubernetes 集群动态配置 Jenkins 代理（使用Kubernetes调度机制来优化负载），运行单个构建，等构建完成后删除该代理。这里我们需要用到这个插件来启动 Jenkins Slave 代理镜像，让代理执行 Jenkins 要执行的 Job。
Kubernetes Cli： Kubernetes Cli 插件作用是在执行 Jenkins Job 时候提供 kubectl 与 Kubernetes 集群交互环境。可以在 Pipeline 或自由式项目中允许执行 kubectl 相关命令。它的主要作用是提供 kubectl 运行环境，当然也可以提供 helm 运行环境。
Config File Provider： Config File Provider 插件作用就是提供在 Jenkins 中存储 properties、xml、json、settings.xml 等信息，可以在执行 Pipeline 过程中可以写入存储的配置。例如，存入一个 Maven 全局 Settings.xml 文件，在执行 Pipeline Job 时候引入该 Settings.xml ，这样 Maven 编译用的就是该全局的 Settings.xml。
Pipeline Utility Steps： 这是一个操作文件的插件，例如读写 json、yaml、pom.xml、Properties 等等。在这里主要用这个插件读取 pom.xml 文件的参数设置，获取变量，方便构建 Docker 镜像。
Git Parameter： 能够与 Git 插件结合使用，动态获取 Git 项目中分支信息，在 Jenkins Job 构建前提供分支选项，来让项目执行人员选择拉取对应分支的代码。

# 凭据
Git 认证凭据
Kubernetes Token 凭据
Docker 仓库认证凭据

3.2.1.2 编写pipeline

pipeline {
  agent {
    kubernetes {
      yaml '''
        apiVersion: v1
        kind: Pod
        metadata:
          labels:
            app: maven
        spec:
          nodeSelector:
              kubernetes.io/hostname: worker-01
          volumes:
            - name: kubectl
              hostPath:
                path: /opt/kube/bin/kubectl
            - name: kubeconfig
              hostPath:
                path: /root/.kube/config
          containers: 
          # 必须包含jnlp容器，否则无法连接到Jenkins Master
          - name: jnlp
            image: quanheng.com/pub/jenkins-agent:v1
            workingDir: /home/jenkins/agent
          # 自定义容器，可以定义一些工具，比如maven，git，docker,kubectl，argo等
          - name: kubectl
            image: quanheng.com/k8s/busybox:v1
            volumeMounts:
            - name: kubectl
              mountPath: /usr/bin/kubectl
            - name: kubeconfig
              mountPath: /root/.kube/config
            command:
            - cat
            tty: true
        '''
      retries 2
    }
  }
  # 通过kubectl或helm进行应用管理，或者使用argo rollout等组件进行管理
  stages {
    stage('deploy') {
      steps {
        container('kubectl') {
          sh 'kubectl version'
        }
      }
    }
  }
}