[系统运维] Jenlins Pipeline、声明式（jenkins2.5新加入的语法）企业常用

开发: C++知识库 Java知识库 JavaScript Python PHP知识库人工智能区块链大数据移动开发嵌入式开发工具数据结构与算法开发测试游戏开发网络协议系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑笔记本显卡显示器固态硬盘硬盘耳机手机 iphone vivo oppo 小米华为单反装机图拉丁

-> 系统运维 -> Jenlins Pipeline、声明式（jenkins2.5新加入的语法）企业常用 -> 正文阅读

[系统运维]Jenlins Pipeline、声明式（jenkins2.5新加入的语法）企业常用

文章目录

声明式（jenkins2.5新加入的语法）

在这里插入图片描述

特点：
1.最外层必须由pipline{ //do something }来进行包裹
2.不需要分号作为分隔符，每个语句必须在一行内
3.不能直接使用groovy语句（例如循环判断等），需要被script {}包裹

声明式pipeline案例：

在这里插入图片描述

pipeline{
    agent any   //没有指定agent
    stages{ 	//步骤
        stage('checkout code'){  //第一个步骤
            steps{
                sh 'echo "youngfit!!!"'
            }
        }
    }
}

在这里插入图片描述

pipeline{
    agent any
    stages{
        stage('mvn-version'){
            steps{
                sh 'mvn -v'
            }
        }
        stage('jdk-version'){
            steps{
                sh 'java -version'
            }
        }
    }
}

在这里插入图片描述

参数详解

agent：该部分指定整个Pipeline或特定阶段将在Jenkins环境中执行的位置，具体取决于该agent 部分的放置位置。该部分必须在pipeline块内的顶层定义 ，也可以使用在stage级。
stage：表示这个Pipeline的某一个执行阶段（使用stage使得逻辑变得更加简单明了）
steps: 包含一个或者多个在stage块中执行的step序列（在这里执行操作：运行maven或者部署等等）
environment：指定键值对，可用于step中，主要是为常量或者变量赋值，根据所在的位置来决定其作用范围（类似于java中全局和局部的概念）
options：允许执行pipeline内置的专用选项，也可以使用由插件提供的
parameters:提供触发pipeline时的参数列表
trigger：定义了触发pipeline的方式（jenkins1.x中的pollscm定时构建）
tools:自动安装工具，注意这里使用的一定是在jenkins全局配置中已经定义好了的
when：可以用来执行一些代码逻辑
post:可以根据pipeline的状态来执行一些操作

agent的一些参数如下：
any ： 在任何可用的机器上执行pipeline
none ： 当在pipeline顶层使用none时，每个stage需要指定相应的agent
agent{ label 'slave1'} 
``                     `
## 2.agent指定
2.1 labels

```bash
pipeline{
    agent { label 'master'}  //指定在哪个节点运行，后面的步骤都在指定的节点运行
    stages{
        stage('mvn-version'){
            steps{
                sh 'mvn -v'
            }
        }
        stage('jdk-version'){
            steps{
                sh 'java -version'
            }
        }
    }
}

2.2 agent none

pipeline{
    agent none  //如果这里是none，后面每一步，都要指定运行节点
    stages{
        stage('mvn-version'){
        	agent { label 'master'}
            steps{
                sh 'mvn -v'
            }
        }
        stage('jdk-version'){
        	agent { label 'node'}
            steps{
                sh 'java -version'
            }
        }
    }
}

2.3 agent docker

pipeline {
    agent {
        docker { image 'maven:latest' }
    }
    stages {
        stage('Test') {
            steps {
                sh 'mvn -v'
            }
        }
    }
}

在这里插入图片描述

2.4 options参数详解

## 设置保存最近的记录
options { buildDiscarder(logRotator(numToKeepStr: '1')) }
 
## 禁止并行构建，因为用的worksapce还是同一个
options { disableConcurrentBuilds() }
 
## 跳过默认的代码检出
options { skipDefaultCheckout() }
 
## 设定流水线的超时时间(可用于阶段级别)
options { timeout(time: 1, unit: 'HOURS') }
 
## 设定流水线的重试次数(可用于阶段级别)
options { retry(3) }
 
## 设置日志时间输出(可用于阶段级别)
options { timestamps() }

#示例：

pipeline {
	agent any
    options {
        buildDiscarder(logRotator(numToKeepStr: '1'))
        disableConcurrentBuilds()
        skipDefaultCheckout()
        timeout(time: 1, unit: 'HOURS')
        timestamps()
        retry(3)
    }
    stages {
    	stage ('test1') {
    	    environment {
    	        name = '飞哥'
    	    }
    		steps {
    			sh 'echo "The username  is ${name}"'
    		}
    	}
    }
}

在这里插入图片描述

2.5 environment

pipeline {
    agent any
    environment {
        unit_test = 'true'
        username = 'youngfit'
        company = '云科技有限公司'
    }
    stages {
        stage('Example') {
            steps {
                sh 'echo ${username} 在 ${company} 工作是 ${unit_test}的' 
            }
        }
    }
}

在这里插入图片描述

2.6 parameters

pipeline {
    agent any
    environment {
        unit_test = 'true'
        username = 'youngfit'
        company = '云科技有限公司'
    }
    parameters {
        string defaultValue: 'jenkins:1.1.1', description: '版本号', name: 'Version', trim: true
    }
    stages {
        stage('Example') {
            steps {
                sh 'echo ${username} 在 ${company} 工作是 ${unit_test}的' 
                echo "${params.Version}"
            }
        }
    }
}

在这里插入图片描述

2.7 tools

// String description = "版本号"
pipeline {
    agent any
    environment {
        unit_test = 'true'
        username = 'youngfit'
        company = '云科技有限公司'
    }
    parameters {
        string defaultValue: 'jenkins:1.1.1', description: '版本号', name: 'Version', trim: true
    }
    tools {
        maven 'maven-jdk8'
        jdk 'java1.8'
    }
    stages {
        stage('Example') {
            steps {
                sh 'echo ${username} 在 ${company} 工作是 ${unit_test}的' 
                echo "${params.Version}"
                sh 'java -version'
                sh 'mvn -v'
            }
        }
    }
}

在这里插入图片描述

2.8 Parallel并串行化

// String description = "版本号"
pipeline {
    agent any
    stages {
        stage('Stage1') {
            steps {
                sh 'echo "步骤1"'
            }
        }
        stage('并行执行的 Stage') {
            parallel {
                stage('Stage2.1') {   //Stage2.1、2.2和2.3是并行的，但是Stage2.3中的2步仍是串行的
                    // agent { label "test1" }
                    steps {
                        echo "在 agent test1 上执行的并行任务 1."
                    }
                }
                stage('Stage2.2') {
                    // agent { label "test2" }
                    steps {
                        echo "在 agent test2 上执行的并行任务 2."
                    }
                }
                stage('Stage2.3') {
                    stages {
                        stage ('串行1') {
                            steps {
                                echo "在 agent test2 上执行的串行任务 1."
                            } 
                        }
                        stage ('串行2') {
                            steps {
                                echo "在 agent test2 上执行的串行任务 2."
                            }
                        }
                    }
                }
            }
        }
    }
}

在这里插入图片描述

2.9 post钩子

post 步骤在Jenkins pipeline语法中是可选的，包含的是整个pipeline或阶段完成后一些附加的步骤。 比如我们希望整个pipeline执行完成之后或pipeline的某个stage执行成功后发生一封邮件，就可以使用post，可以理解为”钩子“。

根据pipeline或阶段的完成状态，post部分分成多种条件块，包括： 
? always：不论当前完成状态是什么，都执行。 
? changed：只要当前完成状态与上一次完成状态不同就执行。 
? fixed：上一次完成状态为失败或不稳定（unstable），当前完成状态为成功时执行。 
? regression：上一次完成状态为成功，当前完成状态为失败、不稳定或中止（aborted）时执行。 
? aborted：当前执行结果是中止状态时（一般为人为中止）执行。 
? failure：当前完成状态为失败时执行。 
? success：当前完成状态为成功时执行。 
? unstable：当前完成状态为不稳定时执行。 
? cleanup：清理条件块。不论当前完成状态是什么，在其他所有条件块执行完成后都执行。post部分可以同时包含多种条件块。

以下是 post 部分的完整示例

pipeline {
  agent { label 'master' }
  stages {
     stage('buildCode') {
       steps {
         echo "building all codes1"
       } 
      post {
        always {
          echo 'scp code.tar to apps'
        }
      }
     }
  }

  post {
    changed {
       echo 'pipeline post changed'
    }
    always {
       echo 'pipeline post always'
    }
    success {
       echo 'pipeline post success'
    }
    // 省略其他条件块
  }
}

在这里插入图片描述

//failure测试
pipeline {
  agent { label 'master' }
  stages {
     stage('buildCode') {
       steps {
         echo "building all codes1"
       } 
      post {
        always {
          sh 'mkdir /opt/a/ab'   //这一步是会失败的
        }
      }
     }
  }

  post {
    failure {
        echo 'pipeline post failure'   //会执行这一步
    }
  }
}

在这里插入图片描述
其他的，兄弟们就自己玩着测试吧！！！

2.10 when

指令2： when

该when指令允许Pipeline根据给定的条件确定是否执行该阶段。该when指令必须至少包含一个条件。如果when指令包含多个条件，则所有子条件必须为舞台执行返回true。这与子条件嵌套在一个allOf条件中相同（见下面的例子）。

更复杂的条件结构可使用嵌套条件建：not，allOf或anyOf。嵌套条件可以嵌套到任意深度。When{…}是写在stage{…}里面一层条件控制，下面来看看when{…}支持的一些内置条件命令。

branch
当正在构建的分支与给出的分支模式匹配时执行阶段，例如：when { branch 'master' }。请注意，这仅适用于多分支Pipeline。

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' } }
举例一个 使用expression条件的when的代码示例。

pipeline {
    agent any
    stages {
        stage('Example Build') {
            steps {
                script {
                    echo 'Hello World'
                }
            }
        }
        stage('Example Deploy') {
            when {
                expression { 
                   return  (1 == 1) //返回值为True
                }
            }
            steps {
                echo 'Deploying'
            }
        }
    }
}

在这里插入图片描述

##environment测试
pipeline {
    agent any
    environment {
        username = 'youngfit'
    }
    stages {
        stage('Example Build') {
            steps {
                script {
                    echo 'Hello World'
                }
            }
        }
        stage('Example Deploy') {
            when {
                environment name: 'username', value: 'youngfit'
            }
            steps {
                echo 'youngfit'
            }
        }
    }
}

在这里插入图片描述

2.11 pipeline scm

在这里插入图片描述

2.12 pipeline scm项目实战

本次构建基于二.12之后

将代码写入仓库的Jenkinsfile中；进行构建:

node {
    def gitUrl = "git@gitee.com:youngfit/easy-springmvc-maven.git"
    def git_Branch = 'master'
    value = "=========================================================="
    stage ('拉取代码') {
        print "${value}"
        git branch: "${git_Branch}", url: "${gitUrl}", credentialsId: "1"
    }
    
    stage ('编译打包') {
        print "${value}"
        sh 'mvn clean package'
    }
    
    stage ('scp发布到tomcat后端服务') {
        print '${values}'
        sh 'ansible-playbook /etc/ansible/jenknis_scp.yaml'
        // sh 'sleep 40'
        sh 'ansible java-server1 -m shell -a "nohup /opt/script/app-jenkins.sh &"'
    }
}