Jenkins Pipeline 是 Jenkins 的核心能力——用代码定义完整的交付流水线。Pipeline 有两种写法：Declarative（声明式）和 Scripted（脚本式）。本篇详解两种语法的区别、选择策略和编写技巧，让你能独立编写生产级流水线。

| 语法 | 结构化 YAML 风格 | Groovy 脚本 |

| 灵活性 | 中（但足够覆盖90%场景） | 高 |

| 推荐场景 | 90% 的流水线 | 复杂条件逻辑 |

结论：优先用 Declarative，只有遇到它无法表达的复杂逻辑时才回退到 Scripted。

pipeline {
    agent any  // 在任意可用节点执行
    
    environment {
        // 环境变量定义
        APP_NAME = 'myapp'
        VERSION = "${env.BUILD_NUMBER}"
        DOCKER_REGISTRY = 'registry.mycompany.com'
    }
    
    options {
        // 流水线选项
        timeout(time: 30, unit: 'MINUTES')
        buildDiscarder(logRotator(numToKeepStr: '20'))
        disableConcurrentBuilds()  // 禁止并发构建
    }
    
    parameters {
        // 参数定义
        choice(name: 'ENV', choices: ['dev', 'test', 'staging', 'prod'], description: '部署环境')
        string(name: 'IMAGE_TAG', defaultValue: 'latest', description: '镜像标签')
        booleanParam(name: 'SKIP_TESTS', defaultValue: false, description: '是否跳过测试')
    }
    
    triggers {
        // 触发器
        cron('H 2 * * *')  // 每天凌晨2点执行
    }
    
    stages {
        stage('Build') {
            steps {
                sh 'mvn clean package -DskipTests'
            }
        }
        
        stage('Test') {
            when {
                expression { !params.SKIP_TESTS }
            }
            steps {
                sh 'mvn test'
            }
            post {
                always {
                    junit 'target/surefire-reports/TEST-*.xml'
                }
            }
        }
    }
    
    post {
        success {
            echo 'Pipeline succeeded!'
        }
        failure {
            echo 'Pipeline failed!'
            emailext to: 'team@mycompany.com', subject: 'Build Failed: ${JOB_NAME} #${BUILD_NUMBER}'
        }
        always {
            cleanWs()  // 清理工作空间
        }
    }
}

pipeline {
    // 方式1：任意节点
    agent any
    
    // 方式2：指定标签的节点
    agent { label 'docker-build' }
    
    // 方式3：指定 Docker 镜像（不需要预装工具）
    agent {
        docker {
            image 'maven:3.9-eclipse-temurin-17'
            args '-v $HOME/.m2:/root/.m2 -v $HOME/.gradle:/root/.gradle'
            label 'docker-build'
        }
    }
    
    // 方式4：Kubernetes Pod（需要 K8s 插件）
    agent {
        kubernetes {
            label 'mypod'
            yaml '''
apiVersion: v1
kind: Pod
spec:
  containers:
  - name: maven
    image: maven:3.9-eclipse-temurin-17
    command: ['cat']
    volumeMounts:
    - mountPath: /root/.m2
      name: maven-cache
  volumes:
  - name: maven-cache
    persistentVolumeClaim:
      claimName: maven-cache-pvc
'''
        }
    }
}

pipeline {
    environment {
        // 静态值
        APP_NAME = 'myapp'
        
        // 引用构建号
        BUILD_TAG = "build-${BUILD_NUMBER}"
        
        // 引用凭据（敏感信息）
        DB_PASSWORD = credentials('db-password')  // 会生成 DB_PASSWORD 和 DB_PASSWORD_USR 变量
        
        // 条件赋值
        DEPLOY_ENV = "${env.BRANCH_NAME == 'main' ? 'prod' : 'dev'}"
    }
    
    stages {
        stage('Config') {
            // 局部环境变量，只在此 stage 生效
            environment {
                LOCAL_VAR = 'stage-specific'
            }
            steps {
                echo "APP_NAME=${APP_NAME}"
                echo "DEPLOY_ENV=${DEPLOY_ENV}"
                // 使用凭据时用 $ 而非 ${} 在 sh 中
                sh 'echo $DB_PASSWORD | wc -c'
            }
        }
    }
}

stages {
    stage('Deploy Prod') {
        when {
            branch 'main'           // 只在 main 分支执行
            // expression { env.BRANCH_NAME == 'main' }  // 等价写法
        }
        steps {
            sh './deploy.sh prod'
        }
    }
    
    stage('Deploy Dev') {
        when {
            branch 'dev'
        }
        steps {
            sh './deploy.sh dev'
        }
    }
    
    stage('Nightly Build') {
        when {
            triggeredBy 'TimerTrigger'  // 只在定时触发时执行
        }
        steps {
            sh './run-full-test-suite.sh'
        }
    }
    
    stage('Skip on PR') {
        when {
            not { changeRequest() }  // 非 PR 时执行
        }
        steps {
            sh './heavy-test.sh'
        }
    }
}

stage('Test') {
    parallel {
        stage('Unit Test') {
            steps {
                sh 'mvn test'
            }
        }
        stage('Integration Test') {
            steps {
                sh 'mvn verify -Pintegration'
            }
        }
        stage('Code Scan') {
            steps {
                sh 'sonar-scanner'
            }
        }
    }
}

script 块：在 Declarative 中嵌入 Groovy

stage('Dynamic Deploy') {
    steps {
        script {
            // 在 Declarative 中使用 Groovy 逻辑
            def services = ['user-service', 'order-service', 'payment-service']
            for (service in services) {
                echo "Deploying ${service}..."
                sh "kubectl set image deployment/${service} app=myapp:${BUILD_NUMBER} -n prod"
            }
        }
    }
}

// Scripted Pipeline 没有外层 pipeline {} 块
// 直接写 Groovy 脚本

node('docker-build') {
    // 定义环境变量
    def appName = 'myapp'
    def version = env.BUILD_NUMBER
    
    try {
        stage('Checkout') {
            checkout scm
        }
        
        stage('Build') {
            sh 'mvn clean package -DskipTests'
            // 归档构建产物
            archiveArtifacts artifacts: 'target/*.jar', fingerprint: true
        }
        
        stage('Test') {
            sh 'mvn test'
            step([$class: 'JUnitResultArchiver', testResults: '**/surefire-reports/TEST-*.xml'])
        }
        
        stage('Deploy') {
            if (env.BRANCH_NAME == 'main') {
                sh "./deploy.sh prod ${version}"
            } else {
                sh "./deploy.sh dev ${version}"
            }
        }
        
    } catch (Exception e) {
        // 错误处理
        emailext to: 'team@mycompany.com',
            subject: "Build Failed: ${env.JOB_NAME} #${env.BUILD_NUMBER}",
            body: "Check: ${env.BUILD_URL}"
        throw e  // 重新抛出，让 Jenkins 标记为失败
    } finally {
        // 清理
        cleanWs()
    }
}

node('docker-build') {
    stage('Multi-Service Deploy') {
        def services = [
            [name: 'user-service', replicas: 3],
            [name: 'order-service', replicas: 2],
            [name: 'payment-service', replicas: 2]
        ]
        
        for (svc in services) {
            echo "Deploying ${svc.name} with ${svc.replicas} replicas"
            sh "kubectl set image deployment/${svc.name} app=myapp:${env.BUILD_NUMBER} -n prod"
            sh "kubectl scale deployment/${svc.name} --replicas=${svc.replicas} -n prod"
            sh "kubectl rollout status deployment/${svc.name} -n prod --timeout=120s"
        }
    }
}

def branches = [:]
branches['unit-test'] = {
    node('java-build') {
        stage('Unit Test') {
            sh 'mvn test'
        }
    }
}
branches['integration-test'] = {
    node('java-build') {
        stage('Integration Test') {
            sh 'mvn verify -Pintegration'
        }
    }
}
branches['code-scan'] = {
    node('java-build') {
        stage('Code Scan') {
            sh 'sonar-scanner'
        }
    }
}

parallel branches  // 并行执行所有分支

四、实战对比：同一个需求的两种写法

根据分支决定部署环境：main→生产，develop→测试，其他→不部署。

pipeline {
    agent any
    stages {
        stage('Build') { steps { sh 'mvn clean package' } }
        
        stage('Deploy') {
            stages {
                stage('Deploy Prod') {
                    when { branch 'main' }
                    steps { sh './deploy.sh prod' }
                }
                stage('Deploy Test') {
                    when { branch 'develop' }
                    steps { sh './deploy.sh test' }
                }
            }
        }
    }
}

node {
    stage('Build') {
        sh 'mvn clean package'
    }
    stage('Deploy') {
        if (env.BRANCH_NAME == 'main') {
            sh './deploy.sh prod'
        } else if (env.BRANCH_NAME == 'develop') {
            sh './deploy.sh test'
        } else {
            echo "Branch ${env.BRANCH_NAME} does not trigger deployment"
        }
    }
}

：《Jenkinsfile 最佳实践：多分支流水线与共享库》——从语法层面进入工程层面，学习如何管理多个项目的 Jenkinsfile 和复用流水线代码。

前言 Jenkins Pipeline 是 Jenkins 的核心能力——用代码定义完整的交付流水线。Pipeline 有两种写法：Declarative（声明式）和 Scripted（脚本式）。本篇详解两种语法的区别、选择策略和编写技巧，让你能独立编写生产级流水线。 一、两种语法的选择 维度 Declarative Scripted 语法 结构化 YAML 风格 Groovy 脚本 上手难度 低...

【CI/CD·Jenkins篇】Pipeline 基础：Declarative 与 Scripted 语法详解

研发部经理

人工智能

Jenkins Pipeline核心语法详解：对比Declarative与Scripted两种写法，涵盖agent、environment、when、parallel等关键指令，提供实战案例与内置变量速查。优先推荐声明式语法，复杂逻辑用script块嵌入Groovy，Docker agent确保构建环境确定性，助你快速编写生产级流水线。

Docker

Agent

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

EdgeOne AI 安全实战专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

Jenkins Pipeline核心语法详解：对比Declarative与Scripted两种写法，涵盖agent、environment、when、parallel等关键指令，提供实战案例与内置变量速查。优先推荐声明式语法，复杂逻辑用script块嵌入Groovy，Docker agent确保构建环境确定性，助你快速...

【CI/CD·Jenkins篇】Pipeline 基础：Declarative 与 Scripted 语法详解

【CI/CD·Jenkins篇】Pipeline 基础：Declarative 与 Scripted 语法详解

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐