Jenkins-Pipeline语法示例

文章目录

1.流水线任务
[2.Jenkins Pipeline](#2.Jenkins Pipeline)
3.Pipeline参数构建后，自动显示
1.流水线任务

2.Jenkins Pipeline

json 复制代码
pipeline {
    // 指定执行节点，none表示没有全局的agent配置，当为none时，每个stage都必须设置自己的agent
    // agent any
    agent none
    
    options {
        // 超时时间5小时，如果不加unit参数，默认分钟
        timeout(time:5, unit: 'HOURS')
        // 所有输出行都会打印时间戳
        timestamps()
        // 流水线失败后重试次数
        retry(3)
    }
    
    // 参数列表，设置后，参数会自动显示在页面上
    parameters {
        string(name: 'CLUSTER_IP', defaultValue: '192.168.120.11', description: '待升级的集群，选择其中一个节点')
        choice(name: 'DOWNLOAD_SOURCE', choices: ['ftp', 'jfrog'], description: '指定下载源')
        choice(name: 'UPGRADE_VERSION_PREFIX', choices: ['2026.01.x'], description: '待升级版本的前缀')
        booleanParam(name: 'IS_DAILY', defaultValue: true, description: '是否升级日构建版本，True是日构建，False不是日构建')        
    }
    
    // 定义全局变量
    environment {
        APP_NAME = 'Big Data'
    }
    
    // 定义全局变量
    stages {
        stage('Hello') {
            // agent {label 'master'}
            agent {
                node {
                    // 根据标签选定节点
                    label 'master'
                    // 设置默认工作目录
                    customWorkspace 'D:\\JenkinsWorkSpace'
                }
            }
            
            options {
                // 超时时间1分钟，如果不加unit参数，默认分钟
                timeout(time:1, unit: 'SECONDS')
                // 所有输出行都会打印时间戳，该stage会打印两个字符串，全局变量一个，本次一个
                timestamps()
                // 流水线失败后重试次数
                retry(2) 
            }
            
            // 定义局部变量
            environment {
                APP_NAME = 'Small Data'
                APP_VERSION = '2026.01.12'
            }
            
            // 执行一个或多个步骤
            steps {
                // 注意：引用变量时，使用双引号，单引号不生效
                echo "Hello ${env.APP_NAME} ${env.APP_VERSION}"
                echo "CLUSTER_IP: ${params.CLUSTER_IP}"
                echo "DOWNLOAD_SOURCE: ${params.DOWNLOAD_SOURCE}"
                echo "UPGRADE_VERSION_PREFIX: ${params.UPGRADE_VERSION_PREFIX}"
                echo "IS_DAILY: ${params.IS_DAILY}"
            }
            
            // 表示 stage('Hello') 执行失败后的处理，失败后，整个流程阻断
            post {
                failure {
                    echo 'Command execution failed!!!'
                }
            }
        }
        
        // 定义并行执行
        stage('Automated Test') {
            parallel {
                // 并行执行，等所有并行任务执行结束后，再触发下一个步骤执行
                stage('Unit Test') {
                    agent {label 'master'}
                    steps {
                        echo "Hello ${env.APP_NAME} ${env.APP_VERSION}"
                        echo 'Unit Test...'
                        echo "开始等待 5 秒..."
                        sleep(time: 5, unit: 'SECONDS')
                        echo "等待 5 秒结束"
                        echo 'Unit Test End'
                    }
                }
                
                stage('Interface Test') {
                    agent {label 'master'}
                    steps {
                        echo 'Interface Test...'
                        echo "开始等待 10 秒..."
                        sleep(time: 10, unit: 'SECONDS')
                        echo "等待 10 秒结束"
                        echo 'Interface Test End'
                    }
                }
                
                
                stage('Batch Test') {
                    agent {label 'master'}
                    
                    stages {
                        stage('Nested 1') {
                            steps {
                                echo 'Nested 1...'
                                echo "开始等待 10 秒..."
                                sleep(time: 10, unit: 'SECONDS')
                                echo "等待 10 秒结束"
                                echo 'Nested 1 End'
                            }
                        }
                        
                        stage('Nested 2') {
                            steps {
                                echo 'Nested 2...'
                                echo "开始等待 10 秒..."
                                sleep(time: 10, unit: 'SECONDS')
                                echo "等待 10 秒结束"
                                echo 'Nested 2 End'
                            }
                        }
                    }
                }
                
            }

        }
        
        // 所有并行任务执行结束后，才会执行
        stage('World') {
            agent {label 'master'}
            steps {
                echo "Hello ${env.APP_NAME} ${env.APP_VERSION}"
                echo 'World'
            }
        }
        
        stage('Hello Ceph') {
            agent {label 'master'}
            
            // 当DOWNLOAD_SOURCE为ftp时才会执行该stage
            when {
                environment name: 'DOWNLOAD_SOURCE', value: 'ftp'
            }
            
            steps {
                echo "Hello ${env.APP_NAME} ${env.APP_VERSION}"
                echo 'Hello Ceph'
            }
        }
        
        stage('Hello Hadoop') {
            agent {label 'master'}
            
            // 当DOWNLOAD_SOURCE为ftp时或者CLUSTER_IP为192.168.120.11，才会执行该stage
            when {
                anyOf {
                    environment name: 'DOWNLOAD_SOURCE', value: 'ftp'
                    environment name: 'CLUSTER_IP', value: '192.168.120.11'
                }
            }
            
            steps {
                echo "Hello ${env.APP_NAME} ${env.APP_VERSION}"
                echo 'Hello Hadoop'
            }
        }

    }
    
    // 定义构建后的操作
    post {
        // 无论stage的完成状态如何，都会执行
        always {
            echo "I will always say Hello World agent!"
        }
    }
    
}
3.Pipeline参数构建后，自动显示

不需要手动配置参数，在Pipeline语法中配置参数后，会自动显示在页面上