Jenkins脚本如何动态生成构建参数

本文目录导读：

1. 使用Active Choices插件（推荐）
2. 使用动态参数脚本
3. 使用Extended Choice Parameter插件
4. 使用可选参数插件（Parameter Separator）
5. 使用共享库动态生成参数
6. 动态参数生成脚本示例
7. 最佳实践

在Jenkins中动态生成构建参数有多种方法,以下是几种常见且实用的实现方式：

使用Active Choices插件（推荐）

安装插件

• Active Choices Plugin
• Active Choices Reactive Parameter

示例：动态下拉列表

// 动态生成选项列表
def branches = ['master', 'develop', 'feature/*']
def getBranches() {
    // 可以从Git API、文件、数据库等动态获取
    return ['master', 'develop', 'release-1.0', 'hotfix-2.1']
}
properties([
    parameters([
        // 动态下拉列表
        [$class: 'CascadeChoiceParameter',
         name: 'BRANCH',
         description: '选择分支',
         filterable: true,
         choiceType: 'PT_SINGLE_SELECT',
         groovyScript: [
            // 初始化脚本
            script: [
                // 返回选项列表
                return getBranches()
            ],
            fallbackScript: [
                return ['error']
            ]
         ]
        ],
        // 动态复选框列表
        [$class: 'CascadeChoiceParameter',
         name: 'MODULES',
         description: '选择模块',
         filterable: true,
         choiceType: 'PT_CHECKBOX',
         groovyScript: [
            script: [
                def modules = ['module-a', 'module-b', 'module-c']
                // 可以根据依赖关系过滤
                if (BRANCH == 'master') {
                    modules += ['module-d']
                }
                return modules
            ],
            fallbackScript: [
                return ['error']
            ]
         ]
        ]
    ])
])
pipeline {
    agent any
    stages {
        stage('构建') {
            steps {
                echo "分支: ${params.BRANCH}"
                echo "模块: ${params.MODULES}"
            }
        }
    }
}

使用动态参数脚本

// 从JSON文件动态生成参数
def loadDynamicParams() {
    def configFile = readFile('config/params.json')
    def config = new groovy.json.JsonSlurper().parseText(configFile)
    def params = []
    config.each { param ->
        if (param.type == 'choice') {
            params << choice(
                name: param.name,
                description: param.description,
                choices: param.options.join('\n')
            )
        } else if (param.type == 'string') {
            params << string(
                name: param.name,
                defaultValue: param.defaultValue,
                description: param.description
            )
        } else if (param.type == 'boolean') {
            params << booleanParam(
                name: param.name,
                defaultValue: param.defaultValue,
                description: param.description
            )
        }
    }
    return params
}
properties([
    parameters(loadDynamicParams())
])

使用Extended Choice Parameter插件

properties([
    parameters([
        extendedChoice(
            name: 'ENVIRONMENTS',
            description: '选择部署环境',
            type: 'PT_CHECKBOX',
            value: 'dev,staging,prod',
            // 动态从脚本获取
            groovyScript: [
                script: '''
                    def environments = []
                    // 可以从外部API动态获取
                    def result = ["http://api.example.com/environments"].toURL().text
                    def json = new groovy.json.JsonSlurper().parseText(result)
                    json.each { env ->
                        environments << "${env.name}:${env.url}"
                    }
                    return environments
                ''',
                fallback: 'dev,staging'
            ]
        )
    ])
])

使用可选参数插件（Parameter Separator）

properties([
    parameters([
        // 条件显示参数
        [
            $class: 'BooleanParameterDefinition',
            name: 'USE_CUSTOM_CONFIG',
            defaultValue: false,
            description: '使用自定义配置'
        ],
        // 根据条件动态显示/隐藏
        [
            $class: 'CascadeChoiceParameter',
            name: 'CUSTOM_CONFIG_FILE',
            description: '选择配置文件',
            filterable: true,
            choiceType: 'PT_SINGLE_SELECT',
            referencedParameters: 'USE_CUSTOM_CONFIG',
            script: [
                groovyScript: [
                    script: [
                        if (USE_CUSTOM_CONFIG) {
                            return ['config-dev.yaml', 'config-prod.yaml']
                        } else {
                            return ['default-config.yaml']
                        }
                    ]
                ]
            ]
        ]
    ])
])

使用共享库动态生成参数

vars/dynamicParams.groovy

def call() {
    def params = []
    // 从数据库获取参数模板
    def dbParams = getParamsFromDB('build_params')
    dbParams.each { param ->
        switch(param.type) {
            case 'choice':
                params << choice(
                    name: param.name,
                    choices: param.options.join('\n'),
                    description: param.description
                )
                break
            case 'string':
                params << string(
                    name: param.name,
                    defaultValue: param.defaultValue,
                    description: param.description
                )
                break
        }
    }
    return params
}
def getParamsFromDB(templateName) {
    // 实现数据库查询逻辑
    return [
        [name: 'DB_HOST', type: 'string', defaultValue: 'localhost', description: '数据库主机'],
        [name: 'DB_PORT', type: 'string', defaultValue: '3306', description: '数据库端口']
    ]
}

Jenkinsfile中使用

@Library('my-shared-lib') _
pipeline {
    agent any
    parameters {
        dynamicParams()
    }
    stages {
        stage('使用参数') {
            steps {
                echo "DB Host: ${params.DB_HOST}"
                echo "DB Port: ${params.DB_PORT}"
            }
        }
    }
}

动态参数生成脚本示例

// 完整的动态参数示例
node {
    // 获取动态数据
    def envList = ['dev', 'staging', 'prod']
    def serviceList = ['api', 'web', 'worker']
    // 生成动态参数
    def params = [
        string(
            name: 'PROJECT_NAME',
            defaultValue: 'my-project',
            description: '项目名称'
        ),
        choice(
            name: 'ENVIRONMENT',
            description: '选择环境',
            choices: envList.join('\n')
        ),
        // 根据环境生成不同的服务列表
        [$class: 'CascadeChoiceParameter',
         name: 'SERVICE',
         description: '选择服务',
         filterable: true,
         choiceType: 'PT_SINGLE_SELECT',
         referencedParameters: 'ENVIRONMENT',
         groovyScript: [
            script: [
                def services = ['api', 'web']
                if (ENVIRONMENT == 'prod') {
                    services << 'worker'
                }
                return services
            ],
            fallbackScript: [
                return ['error']
            ]
         ]
        ]
    ]
    properties([
        parameters(params)
    ])
    // 构建逻辑
    stage('构建') {
        echo "正在构建项目: ${PROJECT_NAME}"
        echo "环境: ${ENVIRONMENT}"
        echo "服务: ${SERVICE}"
    }
}

最佳实践

1. 参数缓存：如果数据源响应慢，考虑缓存动态参数
2. 错误处理：始终提供fallback值
3. 性能优化：避免在参数脚本中进行耗时操作
4. 安全性：不要在参数脚本中暴露敏感信息
5. 版本控制：将参数定义文件存放在版本控制中

这些方法可以根据你的具体需求选择使用，推荐优先使用Active Choices插件,因为它提供了最灵活的动态参数生成能力。