jenkins_Pipeline使用測試

這篇具有很好參考價值的文章主要介紹了jenkins_Pipeline使用測試。希望對大家有所幫助。如果存在錯誤或未考慮完全的地方，請大家不吝賜教，您也可以點擊"舉報違法"按鈕提交疑問。

jenkins—Pipeline使用測試

安裝jenkins

#	jar包啟動
https://sg.mirror.servanamanaged.com/jenkins/war-stable/2.346.1/jenkins.war
https://download.oracle.com/java/17/latest/jdk-17_linux-x64_bin.tar.gz
[root@vm ~]# tail /etc/profile   
...
export JAVA_HOME=/opt/jdk17
export PATH=$PATH:$JAVA_HOME/bin
[root@vm ~]# source /etc/profile
[root@vm ~]# java -version
java version "17.0.10" 2024-01-16 LTS
[root@vm ~]# nohup java -Dhudson.model.DownloadService.noSignatureChecke=true -DJENKINS_HOME=/app/ -jar /app/jenkins.war &

[root@vm ~]# cat /opt/jenkins_home/secrets/initialAdminPassword

# docker 啟動
~]# curl -o /etc/yum.repos.d/docker.repo  http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
~]# curl -o /etc/yum.repos.d/CentOS-Base.repo  https://mirrors.aliyun.com/repo/Centos-7.repo
[root@jenkins ~]# yum -y install docker-ce-19.03.7-3.el7
[root@jenkins ~]# vim  /etc/docker/daemon.json
{
  "registry-mirrors": [
    "https://registry.docker-cn.com",
    "http://hub-mirror.c.163.com",
    "https://docker.mirrors.ustc.edu.cn"
  ]
}
[root@jenkins ~]# docker run -d --name jenkins -p 8080:8080  -u root  -v /opt/jenkins_home:/var/jenkins_home  -v /var/run/docker.sock:/var/run/docker.sock -v /usr/bin/docker:/usr/bin/docker  -v /usr/local/maven:/usr/local/maven  -v /usr/local/jdk:/usr/local/jdk -v /etc/localtime:/etc/localtime --restart=always jenkins/jenkins:2.328

安裝聲明式插件Pipeline:Declarative

Jenkinsfile組成
	指定節(jié)點agent   # node  workspace
    運行選項options
    指定階段stages
    指定構(gòu)建后操作post

創(chuàng)建pipeline流水線

Pipeline script		#直接寫groovy語法構(gòu)建編譯
Pipeline script from SCM	#將上面的構(gòu)建編譯語句寫到文件內(nèi)（Jenkinsfile）并放到代碼倉,這里指定文件位置及沒名字

樣例

string workspace = "/app/jobs/pipeline_test"
pipeline {
    
    //1、指定node節(jié)點/workspace
    agent  any

    //2、構(gòu)建運行選項
    options {
    	timestamps()	//日志會有時間
    	skipDefaultCheckout()	//刪除隱式checkout scm語句
    	disableConcurrentBuilds()	//禁止并行
    	timeout(time:1,unit:'HOURS')	//流水線超時設(shè)置1h
    }

    // 3、指定stages階段	(一個或多個)解釋:在這里添加了三個階段
    stages {
    	//下載代碼
    	stage("GetCode"){ //階段名稱
    		steps{ //步驟
    			timeout(time:5, unit:"MINUTES"){	//步驟超時時間
    				script{ 	//填寫運行代碼
    					println('獲取代碼')
    				}
    			}
    		}
    	}

    	//構(gòu)建
    	stage("Build"){
    		steps{
    			timeout(time:20,unit:"MINUTES"){
    				script{
    					println('應(yīng)用打包')
    				}
    			}
    		}
    	}
	
    	//代碼掃描
    	stage("CodeScan"){
    		steps{
    		    timeout(time:30,unit:"MINUTES"){
    			    script{
    				    println("代碼掃描")
    				}
    			}
    		}
    	}
    }
    
    // 4、指定構(gòu)建后操作,post 與 stages  是同級
    post {
    	always {
    		script{
    			println("always")
    		}
    	}
    	
    	success {
    		script{
    			currentBuild.description += "\n 構(gòu)建成功!"
    		}
    	}
        
        failure {
    		script{
    			currentBuild.description += "\n 構(gòu)建失敗!"
    		}
    	}
    			
    	aborted {
    		script{
    			currentBuild.description += "\n 構(gòu)建取消!"
    		}
    	}
    }
}

1.1 agent(代理)

agent 指定了流水線的執(zhí)行節(jié)點。
參數(shù):
    any 在任何可用的節(jié)點上執(zhí)行pipeline。
    none 沒有指定agent的時候默認
    label 在指定標簽上的節(jié)點上運行Pipeline。
    node 允許額外的選項。
    
這兩種是一樣的
    agent { node { label 'labelname' }}
    agent { label 'labelname' }

1.2 stages(階段)

包含一系列一個或多個 stage 指令,建議 stages 至少包含一個 stage 指令用于連續(xù)交付過程的每個離散部分,比如構(gòu)建,測試,和部署。

1.3 post

定義一個或多個steps,這些階段根據(jù)流水線或階段的完成情況而運行(取決于流水線中 post部分的位置).post支持以下 post-condition 塊中的其中之一: always, changed,failure,success,unstable,和 aborted。這些條件塊允許在 post部分的步驟的執(zhí)行取決于流水線或階段的完成狀態(tài)。

always 無論流水線或者階段的完成狀態(tài)
changed 只有當流水線或者階段完成狀態(tài)與之前不同時。
failure 只有當流水線或者階段狀態(tài)為”failure”運行,
success 只有當流水線或者階段狀態(tài)為”success”運行。
unstable 只有當流水線或者階段狀態(tài)為”unstable”運行。例如:測試失敗。
aborted 只有當流水線或者階段狀態(tài)為"aborted“運行。例如:手動取消，

1.4 steps(步驟)

step是每個階段中要執(zhí)行的每個步驟。

pipeline {
    agent any
    stages {
    	stage('Example'){
            steps {
                echo 'Hello World'
            }
        }
    }      
    
    post{
        always{
    		echo 'I will always say Hello again!'
        }
    }
}

1.5 指令

1.5.1 environment

environment 指令指定一個鍵值對序列,該序列將被定義為所有步驟的環(huán)境變量,或者是特定于階段的步驟,這取決于 environment 指令在流水線內(nèi)的位置。
該指令支持一個特殊的方法 credentials(),該方法可用于在Jenkins環(huán)境中通過標識符訪問預(yù)定義的憑證。
對于類型為“Secret Text”"的憑證,credentials()將確保指定的環(huán)境變量包含秘密文本內(nèi)容。
對于類型為“SStandard username and password”的憑證,指定的環(huán)境變量指定為username:password,并目兩個額外的環(huán)境變量將被自動定義:分別為,MYVABNAME USB 和 MYVABNAME PSW

pipeline {
    agent any
    
    environment {
        CC ='clang'
    }
    stages {
    	stage('Example'){
            steps {
                sh 'printenv'
                echo 'Hello World'
                println("${env.CC}")
            }
        }
    }      
    
    post{
        always{
    		echo 'I will always say Hello again!'
        }
    }
}

1.5.2 options

options 指令允許從流水線內(nèi)部配置特定于流水線的選項。流水線提供了許多這樣的選項,比如buildDiscarder,但也可以由插件提供,比如timestamps，也可以是參數(shù)化構(gòu)建的自定義參數(shù) ${自定義參數(shù)}

buildDiscarder: 為最近的流水線運行的特定數(shù)量保存組件和控制臺輸出
disableConcurrentBuilds:不允許同時執(zhí)行流水線?？杀挥脕矸乐雇瑫r訪問共享資源等overrideIndexTriggers: 允許覆蓋分支索引觸發(fā)器的默認處理。
skipDefaultCheckout: 在 agent 指令中,跳過從源代碼控制中檢出代碼的默認情況skipStagesAfterUnstable:-旦構(gòu)建狀態(tài)變得UNSTABLE,跳過該階段。
checkoutToSubdirectory: 在工作空間的子目錄中自動地執(zhí)行源代碼控制檢出。
timeout: 設(shè)置流水線運行的超時時間,在此之后,Jenkins將中止流水線。
retry: 在失敗時,重新嘗試整個流水線的指定次數(shù)。
timestamps 預(yù)測所有由流水線生成的控制臺輸出,與該流水線發(fā)出的時間一致。

1.5.3 parameters

為流水線運行時設(shè)置項目相關(guān)的參數(shù),參數(shù)的使用需pipeline運行一次后生效，再次運行才能調(diào)用

生產(chǎn)的參數(shù)會體現(xiàn)在參數(shù)化構(gòu)建的web頁面上

web上可以做參數(shù)化構(gòu)建設(shè)置，pipeline 調(diào)用

// string 字符串類型的參數(shù)
parameters { string(name: 'DEPLOY_ENV',defaultValue: 'staging',description: '')}

//booleanParam 布爾參數(shù)
parameters f booleanParam(name: 'DEBUG_BUILD', defaultValue: true, description: '')

pipeline {
    agent any
    // string 字符串類型的參數(shù)
    parameters { string(name: 'DEPLOY_ENV',defaultValue: 'staging',description: '')}
    
    //booleanParam 布爾參數(shù)
    //parameters { booleanParam(name: 'DEBUG_BUILD', defaultValue: true, description: '')}
    
    environment {
        CC ='clang'
    }
    stages {
    	stage('Example'){
            steps {
                println("${DEPLOY_ENV}")	//pipeline shang 設(shè)置的參數(shù)
                println("${plug_set}")	// web上設(shè)置的參數(shù)化構(gòu)建
                echo 'Hello World'
                println("${env.CC}")
            }
        }
    }      
}

1.5.4 觸發(fā)器

構(gòu)建觸發(fā)器

// cron 計劃任務(wù)定期執(zhí)行構(gòu)建，
triggers { cron('H */4 ** 1-5')}

// polISCM 與cron定義類似,但是由jenkins定期檢測源碼變化。
triggers { pollSCM('H */4 ** 1-5')}

// upstream 接受逗號分隔的工作字符串和閾值。 當字符串中的任何作業(yè)以最小閾值結(jié)束時,流水線被重新觸發(fā)。
triggers { upstream(upstreamProjects: 'job1,job2', threshold: hudson.model.Result.SuCcEsS) }

pipeline {
    agent any
    
    triggers {
        cron('H/2 * * * *')  // 沒兩分鐘執(zhí)行一次
    }
    
    stages {
        stage('Example') {
            steps {
                echo 'Hello World'
            }
        }
    }
}

1.5.5 tool

獲取通過自動安裝或手動放置工具的環(huán)境變量。支持maven/idk/gradle。工具的名稱必須在系統(tǒng)設(shè)置->全局工縣配置中定義

pipeline {
    agent any
    tools {
		jdk 'jdk17'    // jdk17 與全局配置里的名字保持一致  
        // jdk  固定命名，Valid tool types: [ant, hudson.tasks.Ant$AntInstallation, git, hudson.plugins.git.GitTool, gradle, hudson.plugins.gradle.GradleInstallation, jdk, hudson.model.JDK, jgit, org.jenkinsci.plugins.gitclient.JGitTool, jgitapache, org.jenkinsci.plugins.gitclient.JGitApacheTool, maven, hudson.tasks.Maven$MavenInstallation]
    }

    stages {
    	stage('Example'){
            steps {
                echo 'Hello World'
                script {
                    JavaHome = tool 'jdk17'    //  工具名
                    println(JavaHome)
                }
            }
        }
    }      
}

1.5.6 input 輸入交互

input用戶在執(zhí)行各個階段的時候,由人工確認是否繼續(xù)進行，

message 呈現(xiàn)給用戶的提示信息
id 可選,默認為stage名稱。
ok 默認表單上的ok文本
submitter 可選的,以逗號分隔的用戶列表或允許提交的外部組名。默認允許任何用戶
submitterParameter 環(huán)境變量的可選名稱。如果存在,用 submitter 名稱設(shè)置。
parameters 提示提交者提供的一個可選的參數(shù)列表，

參考生成流水線腳本，自動生成

pipeline {
    agent any
    stages {
        stage('Example') {
            input {
                message "Should we continue?"
                ok "Yes, we should."
                submitter "admin"
                parameters {
                    string(name: 'PERSON', defaultValue: 'Mr Jenkins', description: 'Who should I say hello to?')
                }
            }
            steps {
                echo "Hello, ${PERSON}, nice to meet you."
            }
        }
    }
}

輸入后執(zhí)行
jenkins_Pipeline使用測試,jenkins使用,jenkins,運維

1.5.7 when

when 指令允許流水線根據(jù)給定的條件決定是否應(yīng)該執(zhí)行階段。whn指令必須包含至少一個條件。如果when指令包含多個條件,所有的子條件必須返回Tue,階段才能執(zhí)行這與子條件在 allOf 條件下嵌套的情況相同。
內(nèi)置條件

branch: 當正在構(gòu)建的分支與模式給定的分支匹配時，執(zhí)行這個階段,這只適用于多分支流水線例如:
when { branch 'master' }

environment: 當指定的環(huán)境變量是給定的值時，執(zhí)行這個步驟,例如:
when { environment name: 'DEPLOY_TO', value: 'production' }

expression 當指定的Groovy表達式評估為true時，執(zhí)行這個階段, 例如:
when { expression { return params.DEBUG_BUILD } }

not 當嵌套條件是錯誤時，執(zhí)行這個階段,必須包含一個條件，例如:
when { not { branch 'master' } }

allOf 當所有的嵌套條件都正確時，執(zhí)行這個階段,必須包含至少一個條件，例如:
when { allOf { branch 'master'; environment name: 'DEPLOY_TO', value: 'production' } }

anyOf 當至少有一個嵌套條件為真時，執(zhí)行這個階段,必須包含至少一個條件，例如:
when { anyOf { branch 'master'; branch 'staging' } }

pipeline {
    agent any
    stages {
        stage('Example Build') {
            steps {
                echo 'Hello World'
            }
        }
        stage('Example Deploy') {
            when {
                not { branch 'master' }   //不是master分支 輸出 Deploying
            }
            steps {
                echo 'Deploying'
            }
        }
    }
}

1.5.8 并行parallel

聲明式流水線的階段可以在他們內(nèi)部聲明多隔嵌套階段,它們將并行執(zhí)行。注意,一個階段必須只有一個steps或parallel的階段。嵌套階段本身不能包含進一步的parallel 階段,但是其他的階段的行為與任何其他 stage parallel的階段不能包含 agent 或 tools階段,因為他們沒有相關(guān) steps
另外,通過添加 failFast true 到包含 parallel的 stage 中,當其中一個進程失敗時,你可以強制所有的 parallel 階段都被終止,

// 指定stages階段(一個或多個)解釋:在這里添加了三個階段
stages {
    stage ("parallel") {
        when {
            branch 'master'
        }
        
        parallel{
            //構(gòu)建
            stage("Build"){
                steps{
                    timeout(time:20,unit:"MINUTES"){
                        script{
                            println('應(yīng)用打包')
                        }
                    }
                }
            }

            //代碼掃描
            stage("CodeScan"){
                steps{timeout(time:30,unit:"MINUTES"){
                    script{
                        println(“代碼掃描”)
                        }
                    }
                }
            }     
	}
}

pipeline {
    agent any
    stages {
        stage('Non-Parallel Stage') {
            steps {
                echo 'This stage will be executed first.'
            }
        }
        stage('Parallel Stage') {
            when {
                not { 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"
                    }
                }
            }
        }
    }
}

//  單機演示
pipeline {
    agent any
    stages {
        stage('Non-Parallel Stage') {
            steps {
                echo 'This stage will be executed first.'
            }
        }
        stage('Parallel Stage') {
            when {
                not { branch 'master' }
            }
            failFast true
            parallel {
                stage('Branch A') {
                    agent any
                    steps {
                        echo "On Branch A"
                    }
                }
                stage('Branch B') {
                    agent any
                    steps {
                        echo "On Branch B"
                    }
                }
            }
        }
    }
}

安裝blueocean，觀察并行效果

1.6 step步驟

1.6.1 script

script 步驟需要 [scripted-pipeline]塊并在聲明式流水線中執(zhí)行。對于大多數(shù)用例來說,應(yīng)該聲明式流水線中的“腳本”步驟是不必要的，但是它可以提供一個有用的”逃生出口”。非平凡的規(guī)模和/或復(fù)雜性的script塊應(yīng)該被轉(zhuǎn)移到共享庫。

示例：

pipeline {
    agent any
    stages {
        stage('Example') {
            steps {
                echo 'Hello World'

                script {
                    def browsers = ['chrome', 'firefox']
                    for (int i = 0; i < browsers.size(); ++i) {
                        echo "Testing the ${browsers[i]} browser"
                    }
                }
            }
        }
    }
}

JenkinsShareLibrary-概述

jenkins_Pipeline使用測試,jenkins使用,jenkins,運維

src目錄類似于標準Java源目錄結(jié)構(gòu)。執(zhí)行流水線時，此目錄將添加到類路徑中，
vars目錄托管腳本文件，這些腳本文件在“管道”中作為變量公開。
resources目錄允許1ibraryResource從外部庫中使用步驟來加載相關(guān)聯(lián)的非Groovy文件。

//  https://github.com/zeyangli/jenkinslib

---------------------------------------------------------------------------------------
//  倉庫文件：/src/org/devops/tools.groovy
package org.devops    //必加項

//打印內(nèi)容
def PrintMes(content){
    println(content)
}
// jenkinslib/vars/hello.groovy

def call(){
    println("hello")

}
//  倉庫文件：/vars/hello.groovy
---------------------------------------------------------------------------------------
def call(){
    println("hello")

}

---------------------------------------------------------------------------------------
//jenkins配置 Libraries  
Dashboard/系統(tǒng)管理/System/  Global Pipeline Libraries   //jenkins配置 Libraries  名字、倉庫地址、憑證

---------------------------------------------------------------------------------------
// Jenkinsfile

#!groovy

@Library('jenkinslib') _  // 上面jenkins配置的Libraries名字
def tools = new org.devops.tools()   // 引用tools.groovy



String workspace = "/opt/jenkins/workspace"

//Pipeline
pipeline {
    agent { node {  label "master"   //指定運行節(jié)點的標簽或者名稱
                    customWorkspace "${workspace}"   //指定運行工作目錄（可選）
            }
    }

    options {
        timestamps()  //日志會有時間
        skipDefaultCheckout()  //刪除隱式checkout scm語句
        disableConcurrentBuilds() //禁止并行
        timeout(time: 1, unit: 'HOURS')  //流水線超時設(shè)置1h
    }

    stages {
        //下載代碼
        stage("GetCode"){ //階段名稱
            when { environment name: 'test', value: 'abcd' }
            steps{  //步驟
                timeout(time:5, unit:"MINUTES"){   //步驟超時時間
                    script{ //填寫運行代碼
                        println('獲取代碼')
                        tools.PrintMes("獲取代碼",'green')
                        println("${test}")
                        
                        input id: 'Test', message: '我們是否要繼續(xù)？', ok: '是，繼續(xù)吧！', parameters: [choice(choices: ['a', 'b'], description: '', name: 'test1')], submitter: 'lizeyang,admin'
                    }
                }
            }
        }

        stage("01"){
            failFast true
            parallel {
        
                //構(gòu)建
                stage("Build"){
                    steps{
                        timeout(time:20, unit:"MINUTES"){
                            script{
                                println('應(yīng)用打包')
                                tools.PrintMes("應(yīng)用打包",'green')
                                mvnHome = tool "m2"
                                println(mvnHome)
                                
                                sh "${mvnHome}/bin/mvn --version"
                            }
                        }
                    }
                }
        
                //代碼掃描
                stage("CodeScan"){
                    steps{
                        timeout(time:30, unit:"MINUTES"){
                            script{
                                print("代碼掃描")
                                tools.PrintMes("調(diào)用tools.groovy的PrintMes")  //調(diào)用tools.groovy的PrintMes
                            }
                        }
                    }
                }
            }
        }
    }

    //構(gòu)建后操作
    post {
        always {
            script{
                println("always")
            }
        }

        success {
            script{
                currentBuild.description = "\n 構(gòu)建成功!" 
            }
        }

        failure {
            script{
                currentBuild.description = "\n 構(gòu)建失敗!" 
            }
        }

        aborted {
            script{
                currentBuild.description = "\n 構(gòu)建取消!" 
            }
        }
    }
}

jenkins要配置sharelibrary

裝AnsiColor插件任務(wù)添加顏色參考流水線語法，xterm方式

//  倉庫文件：/src/org/devops/tools.groovy
//格式化輸出
def PrintMes(value,color){
    colors = ['red'   : "\033[40;31m >>>>>>>>>>>${value}<<<<<<<<<<< \033[0m",
              'blue'  : "\033[47;34m ${value} \033[0m",
              'green' : "[1;32m>>>>>>>>>>${value}>>>>>>>>>> [m",
              'green1' : "\033[40;32m >>>>>>>>>>>${value}<<<<<<<<<<< \033[0m" ]
    ansiColor('xterm') {
        println(colors[color])
    }
}


//  見上面的代碼塊
            steps{  //步驟
                timeout(time:5, unit:"MINUTES"){   //步驟超時時間
                    script{ //填寫運行代碼
                        println('獲取代碼')
                        tools.PrintMes("獲取代碼",'green')
                        println("${test}")

rm方式文章來源地址http://www.zghlxwxcb.cn/news/detail-847269.html

//  倉庫文件：/src/org/devops/tools.groovy
//格式化輸出
def PrintMes(value,color){
    colors = ['red'   : "\033[40;31m >>>>>>>>>>>${value}<<<<<<<<<<< \033[0m",
              'blue'  : "\033[47;34m ${value} \033[0m",
              'green' : "[1;32m>>>>>>>>>>${value}>>>>>>>>>> [m",
              'green1' : "\033[40;32m >>>>>>>>>>>${value}<<<<<<<<<<< \033[0m" ]
    ansiColor('xterm') {
        println(colors[color])
    }
}


//  見上面的代碼塊
            steps{  //步驟
                timeout(time:5, unit:"MINUTES"){   //步驟超時時間
                    script{ //填寫運行代碼
                        println('獲取代碼')
                        tools.PrintMes("獲取代碼",'green')
                        println("${test}")