Jenkins声明式流水线如何在并行阶段的子层级选择agent运行

你遇到的报错是因为混用了声明式流水线的结构规则：声明式流水线要求stage必须直接定义在stages块下，不能嵌套在steps、script或者并行分支的闭包内部，因此你在pi的并行分支逻辑中插入stage会触发语法错误。

方案1：纯声明式嵌套并行结构（推荐，版本固定场景） #

这个方案完全遵循声明式流水线规范，利用Jenkins支持的stage嵌套stages能力，以及顶层并行分支配置，既能实现平台层级的并行，也能实现单平台下多版本的测试任务并行调度，同时每个子任务可以独立指定agent标签。

pipeline {
  agent none // 顶层不指定agent，所有任务都分配到对应标签节点
  stages {
    stage("Run Tests") {
      parallel {
        // pi平台并行分支
        stage("Pi Tests") {
          agent none // 本阶段不占用节点，子stage分别分配
          parallel true // 开启本阶段下所有子版本stage并行执行
          stages {
            stage("Pi && Version1") {
              agent { label "pi&&Version1" }
              options {
                catchError(buildResult: "UNSTABLE", stageResult: "FAILURE")
              }
              steps {
                echo "NODE_NAME = ${env.NODE_NAME}"
                // V1测试逻辑
              }
            }
            stage("Pi && Version2") {
              agent { label "pi&&Version2" }
              options {
                catchError(buildResult: "UNSTABLE", stageResult: "FAILURE")
              }
              steps {
                echo "NODE_NAME = ${env.NODE_NAME}"
                // V2测试逻辑
              }
            }
          }
        }
        // AIX平台并行分支，和Pi平级
        stage("AIX Tests") {
          agent none
          parallel true
          stages {
            stage("AIX && Version1") {
              agent { label "aix&&Version1" }
              options {
                catchError(buildResult: "UNSTABLE", stageResult: "FAILURE")
              }
              steps {
                // AIX V1测试逻辑
              }
            }
            // 其他AIX版本同理
          }
        }
        // macOS、Windows、Linux平台如果不需要分版本，直接写对应stage指定agent即可
        stage("macOS Tests") {
          agent { label "macOS" }
          steps {
            // macOS测试逻辑
          }
        }
        // 其他平台同理
      }
    }
  }
}

这个方案的优势是流水线可视化界面的stage层级清晰，报错定位方便，不需要写额外脚本逻辑，维护成本低。

方案2：动态生成并行任务（灵活，版本动态变化场景） #

如果你的测试版本需要动态配置、不想硬写大量重复stage，可以用这种方案，在script块中通过脚本语法批量生成并行任务，直接用node步骤指定节点标签，绕开声明式的stage语法限制。

pipeline {
  agent any
  stages {
    stage("Run Tests") {
      steps {
        script {
          // 定义所有并行任务容器
          def parallelTasks = [:]
          
          // 批量生成Pi平台的多版本任务
          def piVersions = ["Version1", "Version2"]
          piVersions.each { ver ->
            parallelTasks["pi-${ver}"] = {
              catchError(buildResult: "UNSTABLE", stageResult: "FAILURE") {
                // 直接用node步骤指定对应标签的节点
                node("pi&&${ver}") {
                  echo "NODE_NAME = ${env.NODE_NAME}"
                  // 对应版本测试逻辑
                }
              }
            }
          }
          
          // 批量生成AIX平台的多版本任务
          def aixVersions = ["Version1", "Version3"]
          aixVersions.each { ver ->
            parallelTasks["aix-${ver}"] = {
              catchError(buildResult: "UNSTABLE", stageResult: "FAILURE") {
                node("aix&&${ver}") {
                  // AIX对应版本测试逻辑
                }
              }
            }
          }
          
          // 其他单版本平台直接添加任务
          parallelTasks["macOS"] = {
            node("macOS") {
              // macOS测试逻辑
            }
          }
          parallelTasks["Windows"] = {
            node("Windows") {
              // Windows测试逻辑
            }
          }
          parallelTasks["Linux"] = {
            node("Linux") {
              // Linux测试逻辑
            }
          }
          
          // 执行所有并行任务
          parallel parallelTasks
        }
      }
    }
  }
}

这个方案的优势是灵活性极高，支持通过配置批量生成测试任务，适合版本迭代频繁、测试矩阵大的场景。

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