如何在Jenkins声明式流水线中实现嵌套并行执行？

声明式流水线原生不支持直接在parallel块下平级嵌套另一个parallel块，但可以通过在并行分支下嵌套顺序阶段组的方式实现需求，无需退回纯脚本式流水线，Blue Ocean可正常识别渲染层级。

标准实现（适用于2018年后发布的所有Jenkins版本） #

核心逻辑是将需要并行的逻辑拆分为两个顶层并行分支：

• 分支1：独立执行2p阶段
• 分支2：顺序执行2.1阶段，再执行3阶段下3.1/3.2的内部并行

所有并行分支执行完成后，才会进入最终的4阶段。
完整流水线代码：

pipeline {
    agent { label 'my_node' }
    options {
        timestamps()
        parallelsAlwaysFailFast()
    }
    stages {
        stage('1') {
            steps {
                script {
                    step([$class: 'WsCleanup'])
                }
            }
        }
        stage('并行任务组') {
            parallel {
                stage('2p') {
                    steps {
                        sh 'echo hi 2p'
                    }
                }
                stage('2&3阶段组') {
                    stages {
                        stage('2.1') {
                            steps {
                                sh 'echo hi 2.1'
                            }
                        }
                        stage('3') {
                            parallel {
                                stage('3.1') {
                                    steps {
                                        sh '''
                                            echo hi 3.1
                                        '''
                                    }
                                }
                                stage('3.2') {
                                    steps {
                                        sh '''
                                            echo "hi 3.2"
                                        '''
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
        stage('4') {
            steps {
                sh 'echo end'
            }
        }
    }
}

注意事项 #

• 该写法要求Declarative Pipeline插件版本 >= 1.2，绝大多数在用的Jenkins实例都满足该要求
• 配置的parallelsAlwaysFailFast()规则对所有层级的并行块生效，任意分支失败会立即终止所有正在运行的并行任务
• Blue Ocean会按目标结构渲染执行视图：2p与2&3阶段组并行展示，2&3阶段组下先展示2.1，再展示3阶段下的两个并行子阶段。

低版本兼容方案 #

如果你的Jenkins版本过旧不支持上述嵌套语法，可以在script块中使用脚本式流水线的并行语法实现完全相同的效果：

pipeline {
    agent { label 'my_node' }
    options {
        timestamps()
        parallelsAlwaysFailFast()
    }
    stages {
        stage('1') {
            steps {
                step([$class: 'WsCleanup'])
            }
        }
        stage('并行任务组') {
            steps {
                script {
                    def topParallel = [:]
                    // 定义2p分支
                    topParallel['2p'] = {
                        stage('2p') {
                            sh 'echo hi 2p'
                        }
                    }
                    // 定义2+3序列分支
                    topParallel['2&3阶段组'] = {
                        stage('2.1') {
                            sh 'echo hi 2.1'
                        }
                        def threeParallel = [:]
                        threeParallel['3.1'] = {
                            stage('3.1') {
                                sh 'echo hi 3.1'
                            }
                        }
                        threeParallel['3.2'] = {
                            stage('3.2') {
                                sh 'echo "hi 3.2"'
                            }
                        }
                        parallel(threeParallel)
                    }
                    // 执行顶层并行
                    parallel(topParallel)
                }
            }
        }
        stage('4') {
            steps {
                sh 'echo end'
            }
        }
    }
}

内容的提问来源于stack exchange，提问作者rodee