Jenkins 基础(3)：进阶语法篇 —— 声明式Pipeline深度解析与高频插件#

1
pipeline {
2
    agent any // 1. 整体骨架：指定执行节点（在哪个环境/机器上运行）
3

4
    stages { // 2. 阶段集合：整个构建过程的主体容器
5
        stage('Build') { // 3. 单个阶段：逻辑上的一个步骤，如编译、测试
6
            steps { // 4. 具体执行步骤：真正干活的命令集合
7
                echo 'Building...'
8
            }
9
        }
10
    }
11

12
    post { // 5. 构建后的动作：成功、失败或中止后的清理与通知操作
13
        always {
14
            echo 'This will always run'
15
        }
16
    }
17
}

1
stages {
2
    stage('Test Phase') {
3
        stages { // 嵌套的 stages
4
            stage('Unit Test') {
5
                steps {
6
                    echo "Running unit tests..."
7
                    sh "npm run test:unit"
8
                }
9
            }
10
            stage('Integration Test') {
11
                steps {
12
                    echo "Running integration tests..."
13
                    sh "npm run test:integration"
14
                }
15
            }
16
        }
17
    }
18
}

1
stages {
2
    stage('Checkout') {
3
        steps {
4
            echo "==> 开始拉取代码"
5
            // 高级代码拉取：指定分支与凭证，推荐使用此方式而非简单的 git 命令
6
            checkout([$class: 'GitSCM',
7
                branches: [[name: '*/main']],
8
                userRemoteConfigs: [[credentialsId: 'gitlab-ssh-key', url: 'git@github.com:my-org/my-repo.git']]
9
            ])
10
        }
11
    }
12
    stage('Shell Execution') {
13
        steps {
14
            // 基础：执行 shell 命令
15
            sh 'npm install'
16

17
            // 【进阶】在声明式流水线中，如果需要执行复杂的 Groovy 逻辑（如 if/else 赋值），必须使用 script 块包裹
18
            script {
19
                // returnStdout: true 表示返回标准输出，trim() 用于去除末尾换行符
20
                def nodeVersion = sh(script: 'node -v', returnStdout: true).trim()
21
                echo "当前 Node 版本为: ${nodeVersion}"
22

23
                // returnStatus: true 表示返回退出码。即便命令执行失败（退出码不为0），也不会中断流水线
24
                def status = sh(script: 'npm run test', returnStatus: true)
25
                if (status != 0) {
26
                    echo "⚠️ 测试失败，退出码: ${status}，但我们允许流水线继续！"
27
                }
28
            }
29
        }
30
    }
31
}

1
pipeline {
2
    agent any
3
    environment {
4
        // 1. 普通自定义环境变量
5
        APP_NAME = 'my-springboot-app'
6
        DEPLOY_ENV = 'production'
7

8
        // 2. 凭证绑定到环境变量 (强烈依赖 Credentials Binding 插件)
9
        // 将 Jenkins 中 ID 为 'db-pwd' 的凭证（Secret text类型）赋值给 DB_PASSWORD 变量
10
        DB_PASSWORD = credentials('db-pwd')
11
    }
12
    stages {
13
        stage('Print Env') {
14
            steps {
15
                // 在 Groovy 层面使用 ${变量名} 引用，注意必须使用双引号 "" 包裹字符串
16
                echo "构建项目: ${APP_NAME}, 构建号: ${env.BUILD_NUMBER}"
17

18
                // 在 Shell 脚本中，可以直接像使用普通 Linux 环境变量一样使用它们
19
                sh """
20
                    echo 部署环境: $DEPLOY_ENV
21
                    echo 数据库密码: $DB_PASSWORD
22
                """
23
            }
24
        }
25
    }
26
}

1
pipeline {
2
    agent any
3
    parameters {
4
        // 1. 字符串参数
5
        string(name: 'BRANCH_NAME', defaultValue: 'main', description: '选择需要构建的分支')
6
        // 2. 文本块参数（适合多行长文本输入，如 Release Notes）
7
        text(name: 'RELEASE_NOTES', defaultValue: '无', description: '本次发布的版本说明')
8
        // 3. 布尔值参数（在 UI 上表现为 Checkbox 勾选框）
9
        booleanParam(name: 'RUN_TESTS', defaultValue: true, description: '是否执行深度单元测试')
10
        // 4. 下拉选择参数（限制用户的输入范围，防止输错）
11
        choice(name: 'DEPLOY_TARGET', choices: ['DEV', 'TEST', 'UAT', 'PROD'], description: '选择目标部署环境')
12
        // 5. 密码参数（输入时以掩码 **** 显示，保证安全）
13
        password(name: 'API_TOKEN', defaultValue: '', description: '输入临时的鉴权 Token')
14
    }
15
    stages {
16
        stage('Build Preparation') {
17
            steps {
18
                // 使用 params 对象获取传入的参数
19
                echo "==> 拉取分支: ${params.BRANCH_NAME}"
20
                echo "==> 目标环境: ${params.DEPLOY_TARGET}"
21

22
                script {
23
                    if (params.RUN_TESTS) {
24
                        echo "==> 用户勾选了执行测试，即将开始跑测试用例..."
25
                    } else {
26
                        echo "==> ⚠️ 用户跳过了测试阶段"
27
                    }
28
                }
29
            }
30
        }
31
    }
32
}

1
post {
2
    success {
3
        echo '🎉 构建与部署全部成功！'
4
        // 伪代码：发送企业微信/钉钉通知
5
        sh """
6
            curl -s 'https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=YOUR_KEY' \
7
               -H 'Content-Type: application/json' \
8
               -d '{"msgtype": "markdown", "markdown": {"content": "✅ **构建成功**\\n项目: ${env.JOB_NAME}\\n分支: ${params.BRANCH_NAME}\\n构建号: #${env.BUILD_NUMBER}"}}'
9
        """
10
    }
11
    failure {
12
        echo '❌ 糟糕，构建失败了！请及时检查日志。'
13
        // 发送邮件通知 (需要提前在系统设置中配置 Mailer 插件的 SMTP 信息)
14
        mail to: 'devops-alert@company.com',
15
             subject: "Pipeline Failed: ${currentBuild.fullDisplayName}",
16
             body: "流水线执行失败，请点击链接查看详情: ${env.BUILD_URL}"
17
    }
18
    changed {
19
        echo '⚠️ 流水线状态发生了变化（成功变失败，或失败变成功）'
20
    }
21
    always {
22
        // 清理工作空间，避免磁盘被打满 (推荐安装 Workspace Cleanup 插件)
23
        echo '🧹 正在清理 Workspace...'
24
        cleanWs()
25
    }
26
}

1
stages {
2
    stage('Deploy to Prod') {
3
        // 必须满足以下【所有】条件才执行此阶段
4
        when {
5
            allOf {
6
                branch 'main' // 当前拉取的必须是 main 分支
7
                environment name: 'DEPLOY_ENV', value: 'production' // 环境变量匹配
8
                expression { params.DEPLOY_TARGET == 'PROD' } // Groovy 表达式必须返回 true
9
            }
10
        }
11
        steps {
12
            echo "🚀 Deploying to Production..."
13
        }
14
    }
15

16
    stage('Build Frontend Assets') {
17
        // 基于文件变更触发：非常适合 Monorepo 仓库！
18
        when {
19
            // 只有当 frontend/ 目录下的文件发生改变时，才执行前端构建，节省大量时间
20
            changeset "frontend/**"
21
        }
22
        steps {
23
            sh 'cd frontend && npm run build'
24
        }
25
    }
26
}

1
stage('Parallel Matrix Tests') {
2
    // 核心特性：如果任意一个并行分支失败，立即终止其他仍在运行的分支，节省服务器资源！
3
    failFast true
4

5
    parallel {
6
        stage('Unit Tests - Linux') {
7
            agent { label 'linux-node' }
8
            steps {
9
                echo "Running tests on Linux..."
10
                sh "npm run test"
11
            }
12
        }
13

14
        stage('Unit Tests - Windows') {
15
            agent { label 'windows-node' }
16
            steps {
17
                echo "Running tests on Windows..."
18
                bat "npm run test"
19
            }
20
        }
21

22
        stage('SonarQube Code Analysis') {
23
            steps {
24
                echo "Running SonarQube Scanner..."
25
                sh "sonar-scanner"
26
            }
27
        }
28
    }
29
}

1
stage('Download Heavy Assets') {
2
    options {
3
        timeout(time: 10, unit: 'MINUTES') // 这个stage最多允许执行 10 分钟
4
        retry(3) // 如果阶段失败，最多自动重试 3 次
5
    }
6
    steps {
7
        // 即使这里的 curl 命令失败了，流水线也不会中断
8
        // 但会将当前构建的总体状态标记为 SUCCESS，当前阶段标记为 UNSTABLE（黄色警告状态）
9
        catchError(buildResult: 'SUCCESS', stageResult: 'UNSTABLE') {
10
            sh 'curl -O https://unstable-domain.com/massive-assets.zip'
11
        }
12
    }
13
}

1
stage('Deploy via SSH') {
2
    steps {
3
        // 调用 ID 为 'prod-ssh-key' 的 SSH 秘钥凭证
4
        withCredentials([sshUserPrivateKey(credentialsId: 'prod-ssh-key', keyFileVariable: 'SSH_KEY', usernameVariable: 'SSH_USER')]) {
5
            sh 'scp -i $SSH_KEY dist.zip $SSH_USER@192.168.1.100:/var/www/'
6
        }
7
    }
8
}

1
stage('Read Package.json') {
2
    steps {
3
        script {
4
            // 直接读取项目中的 package.json，并将其解析为对象
5
            def packageJson = readJSON file: 'package.json'
6
            env.APP_VERSION = packageJson.version
7
            echo "当前构建的版本将标记为: v${env.APP_VERSION}"
8
        }
9
    }
10
}