前端进阶指南

什么是 Jenkins Pipeline？

Jenkins Pipeline 是一种将构建、测试和部署流程定义为代码的方式。它允许开发者通过编写脚本来描述整个 CI/CD 流程，而不是通过 Jenkins 的图形界面手动配置。Pipeline 的核心思想是将整个流程分解为多个阶段（Stages），每个阶段包含多个步骤（Steps），从而形成一个完整的流水线。

Pipeline 的优势

可重复性：Pipeline 脚本可以被版本控制，确保每次构建的流程一致。
可维护性：通过代码定义流程，便于团队协作和维护。
灵活性：支持复杂的流程控制，如并行执行、条件判断等。
可视化：Jenkins 提供了 Pipeline 的可视化界面，便于查看每个阶段的执行状态。

Pipeline 的基本结构

Jenkins Pipeline 通常由以下几个部分组成：

Pipeline 块：定义整个流水线的开始。
Agent：指定流水线在哪个节点上运行。
Stages：定义流水线的各个阶段。
Steps：每个阶段中的具体操作。

以下是一个简单的 Pipeline 示例：

groovy

pipeline {
    agent any

    stages {
        stage('Build') {
            steps {
                echo 'Building the application...'
                sh 'mvn clean package'
            }
        }
        stage('Test') {
            steps {
                echo 'Running tests...'
                sh 'mvn test'
            }
        }
        stage('Deploy') {
            steps {
                echo 'Deploying the application...'
                sh 'mvn deploy'
            }
        }
    }
}

在这个示例中，Pipeline 被分为三个阶段：Build、Test 和 Deploy。每个阶段都包含一些具体的步骤，如执行 Maven 命令来构建、测试和部署应用程序。

Pipeline 的实际应用场景

场景 1：多环境部署

在实际开发中，通常需要将应用程序部署到多个环境（如开发、测试、生产）。通过 Jenkins Pipeline，可以轻松实现多环境部署。以下是一个示例：

groovy

pipeline {
    agent any

    stages {
        stage('Build') {
            steps {
                echo 'Building the application...'
                sh 'mvn clean package'
            }
        }
        stage('Test') {
            steps {
                echo 'Running tests...'
                sh 'mvn test'
            }
        }
        stage('Deploy to Dev') {
            steps {
                echo 'Deploying to Dev environment...'
                sh 'mvn deploy -Pdev'
            }
        }
        stage('Deploy to Prod') {
            steps {
                echo 'Deploying to Prod environment...'
                sh 'mvn deploy -Pprod'
            }
        }
    }
}

在这个示例中，Pipeline 包含了两个部署阶段：Deploy to Dev 和 Deploy to Prod，分别用于将应用程序部署到开发环境和生产环境。

场景 2：并行执行任务

在某些情况下，可能需要并行执行多个任务以提高效率。Jenkins Pipeline 支持并行执行，以下是一个示例：

groovy

pipeline {
    agent any

    stages {
        stage('Build and Test') {
            parallel {
                stage('Build') {
                    steps {
                        echo 'Building the application...'
                        sh 'mvn clean package'
                    }
                }
                stage('Test') {
                    steps {
                        echo 'Running tests...'
                        sh 'mvn test'
                    }
                }
            }
        }
        stage('Deploy') {
            steps {
                echo 'Deploying the application...'
                sh 'mvn deploy'
            }
        }
    }
}

在这个示例中，Build 和 Test 阶段被并行执行，从而缩短了整个流水线的执行时间。

Jenkins 声明式流水线

Jenkins声明式流水线是一种用于定义持续集成和持续交付（CI/CD）流程的强大工具。它通过一种结构化的方式描述构建、测试和部署的步骤，使得流水线的编写更加直观和易于维护。本文将带你从基础概念入手，逐步掌握声明式流水线的使用方法。声明式流水线是Jenkins Pipeline的一种语法风格，它使用一种声明式的方式来描述流水线的各个阶段和步骤。与脚本式流水线相比，声明式流水线更加结构化，适合初学者快速上手。声明式流水线的核心是一个pipeline块，其中包含了流水线的各个阶段（stages）和步骤（steps）。每个阶段可以包含多个步骤，这些步骤可以是构建、测试、部署等操作。

声明式流水线的基本结构

以下是一个简单的声明式流水线示例：

groovy

pipeline {
    agent any

    stages {
        stage('Build') {
            steps {
                echo 'Building the application...'
                sh 'mvn clean package'
            }
        }
        stage('Test') {
            steps {
                echo 'Running tests...'
                sh 'mvn test'
            }
        }
        stage('Deploy') {
            steps {
                echo 'Deploying the application...'
                sh 'mvn deploy'
            }
        }
    }
}

在这个示例中，流水线分为三个阶段：Build、Test和Deploy。每个阶段都包含了一些步骤，例如使用echo命令输出信息，或者使用sh命令执行Shell脚本。

声明式流水线的关键概念

1. `pipeline` 块

pipeline块是声明式流水线的根元素，所有的阶段和步骤都定义在这个块中。

2. `agent` 指令

agent指令用于指定流水线在哪个节点上运行。any表示流水线可以在任何可用的节点上运行。

3. `stages` 块

stages块包含了流水线的所有阶段。每个阶段都有一个名称，并且可以包含多个步骤。

4. `stage` 块

stage块定义了一个具体的阶段，例如构建、测试或部署。每个阶段可以包含多个步骤。

5. `steps` 块

steps块包含了阶段中要执行的具体步骤。每个步骤可以是一个命令、脚本或其他操作。

声明式流水线的实际应用场景

假设你正在开发一个Java应用程序，并且希望每次代码提交后自动构建、测试和部署。你可以使用以下声明式流水线来实现这一目标：

groovy

pipeline {
    agent any

    environment {
        VERSION = '1.0.0'
    }

    stages {
        stage('Build') {
            steps {
                echo 'Building the application...'
                sh 'mvn clean package'
            }
        }
        stage('Test') {
            steps {
                echo 'Running tests...'
                sh 'mvn test'
            }
        }
        stage('Deploy') {
            steps {
                echo 'Deploying the application...'
                sh "mvn deploy -Dversion=${VERSION}"
            }
        }
    }
}

在这个示例中，我们定义了一个environment块来设置版本号，并在部署阶段使用该版本号进行部署。

Jenkins 脚本式流水线

Jenkins是一个广泛使用的持续集成和持续交付（CI/CD）工具，而流水线（Pipeline）是Jenkins的核心功能之一。流水线允许你将构建、测试和部署过程自动化，并定义为一个可重复执行的流程。Jenkins流水线分为两种类型：声明式流水线和脚本式流水线。本文将重点介绍脚本式流水线。脚本式流水线（Scripted Pipeline）是Jenkins流水线的一种类型，它基于Groovy脚本语言。与声明式流水线不同，脚本式流水线提供了更大的灵活性和控制能力，允许你编写复杂的逻辑和条件语句。它适合那些需要高度定制化流程的场景。脚本式流水线的核心是一个Groovy脚本，它定义了构建过程的各个阶段（Stage）和步骤（Step）。每个阶段可以包含多个步骤，步骤是实际执行的任务，例如拉取代码、运行测试或部署应用。

脚本式流水线的基本结构

一个典型的脚本式流水线脚本包含以下几个部分：

节点（Node）：定义流水线运行的Jenkins代理（Agent）。
阶段（Stage）：将流水线划分为多个逻辑阶段，例如构建、测试和部署。
步骤（Step）：在每个阶段中执行的具体任务。

以下是一个简单的脚本式流水线示例：

groovy

node {
    stage('Checkout') {
        // 从Git仓库拉取代码
        checkout scm
    }
    stage('Build') {
        // 构建项目
        sh 'mvn clean package'
    }
    stage('Test') {
        // 运行测试
        sh 'mvn test'
    }
    stage('Deploy') {
        // 部署应用
        sh 'mvn deploy'
    }
}

代码解释

node：指定流水线在哪个Jenkins代理上运行。如果不指定，Jenkins会选择一个可用的代理。
stage：定义一个阶段，例如Checkout、Build、Test和Deploy。
checkout scm：从源代码管理（SCM）系统中拉取代码。
sh：在代理上执行Shell命令。

脚本式流水线的优势

灵活性：脚本式流水线允许你编写复杂的逻辑，例如条件判断、循环和异常处理。
可重用性：你可以将常用的逻辑封装为函数，并在多个流水线中重用。
强大的控制能力：脚本式流水线提供了对构建过程的完全控制，适合需要高度定制化的场景。

实际案例：自动化构建和部署Java应用

假设你有一个Java项目，使用Maven进行构建和测试。以下是一个更复杂的脚本式流水线示例，展示了如何自动化构建、测试和部署过程：

groovy

node {
    stage('Checkout') {
        checkout scm
    }
    stage('Build') {
        try {
            sh 'mvn clean package'
        } catch (Exception e) {
            echo 'Build failed: ' + e.toString()
            currentBuild.result = 'FAILURE'
            throw e
        }
    }
    stage('Test') {
        parallel(
            'Unit Tests': {
                sh 'mvn test'
            },
            'Integration Tests': {
                sh 'mvn verify -Pintegration-tests'
            }
        )
    }
    stage('Deploy') {
        if (env.BRANCH_NAME == 'main') {
            sh 'mvn deploy'
        } else {
            echo 'Skipping deployment for branch: ' + env.BRANCH_NAME
        }
    }
}

代码解释

try-catch：捕获构建过程中的异常，并标记构建结果为失败。
parallel：并行运行单元测试和集成测试，以加快构建速度。
env.BRANCH_NAME：检查当前分支是否为main，只有main分支才会触发部署。

Jenkins的Jenkinsfile

Jenkinsfile 是 Jenkins 流水线的核心配置文件。它允许开发者以代码的形式定义流水线，从而实现自动化构建、测试和部署流程。Jenkinsfile 是一个文本文件，通常存储在项目的根目录中。它使用 Groovy 语法定义 Jenkins 流水线的各个阶段和步骤。通过 Jenkinsfile，开发者可以将整个 CI/CD 流程以代码的形式管理，从而实现版本控制、复用和协作。Jenkinsfile 支持两种语法格式：
声明式流水线（Declarative Pipeline）：更简单、结构化，适合初学者。
脚本式流水线（Scripted Pipeline）：更灵活，适合高级用户。
本文将重点介绍声明式流水线，因为它更易于理解和上手。

Jenkins file 的基本结构

以下是一个简单的 Jenkinsfile 示例，展示了声明式流水线的基本结构：

groovy

pipeline {
    agent any

    stages {
        stage('Build') {
            steps {
                echo 'Building the application...'
            }
        }
        stage('Test') {
            steps {
                echo 'Running tests...'
            }
        }
        stage('Deploy') {
            steps {
                echo 'Deploying the application...'
            }
        }
    }
}

代码解析

pipeline：定义整个流水线的开始。
agent any：指定流水线在任何可用的 Jenkins 代理上运行。
stages：包含多个阶段（stage），每个阶段代表流水线中的一个步骤。
stage('Build')：定义一个名为 "Build" 的阶段。
steps：包含阶段中需要执行的具体操作。
echo：输出一条消息到 Jenkins 控制台。

Jenkins file 的核心概念

1. Agent

agent 用于指定流水线在哪个 Jenkins 节点上运行。常见的选项包括：

any：在任何可用节点上运行。
none：不指定节点，需在每个阶段中单独定义。
docker：在 Docker 容器中运行。

示例：

groovy

agent {
    docker {
        image 'maven:3.8.4'
    }
}

2. Stages 和 Steps

Stages：流水线的主要逻辑块，每个阶段代表一个独立的任务（如构建、测试、部署）。
Steps：阶段中的具体操作，例如执行命令、调用脚本等。

3. Environment

environment 用于定义环境变量，可以在流水线的任何地方使用。

示例：

groovy

environment {
    VERSION = '1.0.0'
}

4. Post Actions

post 用于定义流水线完成后的操作，例如发送通知或清理资源。

示例：

groovy

post {
    success {
        echo 'Pipeline succeeded!'
    }
    failure {
        echo 'Pipeline failed!'
    }
}

实际案例：构建和部署一个 Java 应用

以下是一个完整的 Jenkinsfile 示例，展示了如何构建和部署一个简单的 Java 应用：

groovy

pipeline {
    agent any

    environment {
        VERSION = '1.0.0'
    }

    stages {
        stage('Build') {
            steps {
                echo 'Building the Java application...'
                sh 'mvn clean package'
            }
        }
        stage('Test') {
            steps {
                echo 'Running unit tests...'
                sh 'mvn test'
            }
        }
        stage('Deploy') {
            steps {
                echo 'Deploying the application...'
                sh 'scp target/my-app.jar user@server:/opt/my-app'
            }
        }
    }

    post {
        success {
            echo 'Pipeline completed successfully!'
        }
        failure {
            echo 'Pipeline failed!'
        }
    }
}

代码解析

Build 阶段：使用 Maven 构建 Java 应用。
Test 阶段：运行单元测试。
Deploy 阶段：将构建好的 JAR 文件部署到远程服务器。
Post Actions：根据流水线的执行结果输出成功或失败的消息。

Jenkins 并行执行

并行执行是指在Jenkins流水线中同时运行多个任务，而不是按顺序逐个执行。这种方式可以充分利用多核CPU和分布式构建环境，从而减少整体构建时间。例如，如果你有多个独立的测试套件，可以通过并行执行同时运行它们，而不是等待一个测试套件完成后再运行下一个。并行执行是Jenkins流水线中的一个重要特性，它可以帮助我们显著提高构建效率，尤其是在处理多个任务时。

并行执行的好处

提高效率：并行执行可以显著减少构建时间，尤其是在任务之间没有依赖关系的情况下。
资源优化：通过并行执行，可以更好地利用多核CPU和分布式构建节点，避免资源闲置。
加快反馈：在CI/CD流程中，快速反馈是关键。并行执行可以更快地完成测试和构建，从而加快反馈速度。

在Jenkins流水线中，可以通过parallel指令来实现并行执行。parallel指令允许你定义多个分支，每个分支可以独立运行。

基本语法

groovy

pipeline {
    agent any
    stages {
        stage('Parallel Stage') {
            parallel {
                stage('Task 1') {
                    steps {
                        echo 'Running Task 1'
                    }
                }
                stage('Task 2') {
                    steps {
                        echo 'Running Task 2'
                    }
                }
            }
        }
    }
}

在这个示例中，Task 1和Task 2会同时运行，而不是按顺序执行。

实际案例

假设你有一个项目，需要对不同的操作系统进行测试。你可以通过并行执行来同时运行这些测试任务。

groovy

pipeline {
    agent any
    stages {
        stage('Test on Multiple OS') {
            parallel {
                stage('Test on Windows') {
                    steps {
                        echo 'Running tests on Windows'
                    }
                }
                stage('Test on Linux') {
                    steps {
                        echo 'Running tests on Linux'
                    }
                }
                stage('Test on macOS') {
                    steps {
                        echo 'Running tests on macOS'
                    }
                }
            }
        }
    }
}

在这个案例中，Jenkins会同时在Windows、Linux和macOS上运行测试任务，从而显著减少整体测试时间。

并行执行与依赖关系

需要注意的是，并行执行适用于那些彼此独立的任务。如果任务之间存在依赖关系（例如，任务B需要任务A的输出），则不能简单地使用并行执行。在这种情况下，你可能需要重新设计流水线，或者使用其他机制（如stash和unstash）来传递数据。

Jenkins 条件执行

在Jenkins流水线中，条件执行是一种强大的功能，允许你根据特定条件决定是否执行某些任务或步骤。通过条件执行，你可以更灵活地控制流水线的行为，避免不必要的任务运行，从而提高效率。条件执行是指在流水线中根据某些条件来决定是否执行特定的步骤或任务。这些条件可以是环境变量、参数值、构建状态等。通过条件执行，你可以实现更复杂的逻辑控制，例如跳过某些步骤、仅在特定条件下运行任务等。

在Jenkins流水线中，条件执行通常使用 when 指令来实现。when 指令允许你指定一个条件表达式，只有当该表达式为 true 时，相关的步骤才会被执行。

以下是一个简单的示例：

groovy

pipeline {
    agent any
    stages {
        stage('Build') {
            steps {
                echo 'Building the application...'
            }
        }
        stage('Test') {
            when {
                expression { params.RUN_TESTS == 'true' }
            }
            steps {
                echo 'Running tests...'
            }
        }
        stage('Deploy') {
            steps {
                echo 'Deploying the application...'
            }
        }
    }
}

在这个示例中，Test 阶段只有在 RUN_TESTS 参数为 true 时才会执行。如果 RUN_TESTS 为 false，则 Test 阶段会被跳过。

条件表达式的类型

Jenkins 提供了多种条件表达式，以下是一些常用的类型：

expression: 使用 Groovy 表达式来定义条件。
branch: 仅在特定分支上执行。
environment: 根据环境变量的值来决定是否执行。
not: 对条件取反。
allOf: 所有条件都必须为 true。
anyOf: 任意一个条件为 true 即可。

示例：使用 `branch` 条件

groovy

pipeline {
    agent any
    stages {
        stage('Build') {
            steps {
                echo 'Building the application...'
            }
        }
        stage('Deploy') {
            when {
                branch 'main'
            }
            steps {
                echo 'Deploying to production...'
            }
        }
    }
}

在这个示例中，Deploy 阶段只有在 main 分支上才会执行。

示例：使用 `allOf` 和 `anyOf

groovy

pipeline {
    agent any
    stages {
        stage('Build') {
            steps {
                echo 'Building the application...'
            }
        }
        stage('Test') {
            when {
                allOf {
                    branch 'feature/*'
                    expression { params.RUN_TESTS == 'true' }
                }
            }
            steps {
                echo 'Running tests...'
            }
        }
        stage('Deploy') {
            when {
                anyOf {
                    branch 'main'
                    branch 'release/*'
                }
            }
            steps {
                echo 'Deploying the application...'
            }
        }
    }
}

在这个示例中，Test 阶段只有在 feature/* 分支且 RUN_TESTS 参数为 true 时才会执行。而 Deploy 阶段则在 main 分支或 release/* 分支上执行。

实际案例

假设你正在开发一个 Web 应用程序，并且希望在每次提交到 main 分支时自动部署到生产环境，而在提交到 feature/* 分支时只运行测试。你可以使用以下流水线配置：

groovy

pipeline {
    agent any
    stages {
        stage('Build') {
            steps {
                echo 'Building the application...'
            }
        }
        stage('Test') {
            when {
                branch 'feature/*'
            }
            steps {
                echo 'Running tests...'
            }
        }
        stage('Deploy') {
            when {
                branch 'main'
            }
            steps {
                echo 'Deploying to production...'
            }
        }
    }
}

在这个案例中，Test 阶段仅在 feature/* 分支上运行，而 Deploy 阶段仅在 main 分支上运行。

Jenkins 参数化流水线

Jenkins参数化流水线是一种强大的功能，允许你在运行流水线任务时动态传递参数。这些参数可以是字符串、布尔值、选项列表等，使得流水线能够根据不同的输入执行不同的操作。参数化流水线特别适用于需要根据环境、用户输入或其他条件动态调整构建或部署流程的场景。

通过参数化流水线，你可以减少重复的流水线配置，提高代码的可重用性，并使自动化流程更加灵活。

在Jenkins中，参数化流水线通过在流水线脚本中定义参数来实现。这些参数可以在流水线运行时通过用户输入或外部系统传递。常见的参数类型包括：

string: 字符串类型，用于传递文本值。
booleanParam: 布尔类型，用于传递 true 或 false。
choice: 选择类型，允许用户从预定义的选项列表中选择一个值。
password: 密码类型，用于安全地传递敏感信息。

如何定义参数化流水线

在Jenkins流水线脚本中，你可以使用 parameters 块来定义参数。以下是一个简单的示例：

groovy

pipeline {
    agent any
    parameters {
        string(name: 'BRANCH_NAME', defaultValue: 'main', description: 'Git branch to build')
        booleanParam(name: 'RUN_TESTS', defaultValue: true, description: 'Run tests after build?')
        choice(name: 'ENVIRONMENT', choices: ['dev', 'staging', 'production'], description: 'Select deployment environment')
    }
    stages {
        stage('Build') {
            steps {
                echo "Building branch: ${params.BRANCH_NAME}"
            }
        }
        stage('Test') {
            steps {
                script {
                    if (params.RUN_TESTS) {
                        echo "Running tests..."
                    } else {
                        echo "Skipping tests..."
                    }
                }
            }
        }
        stage('Deploy') {
            steps {
                echo "Deploying to ${params.ENVIRONMENT} environment"
            }
        }
    }
}

在这个示例中，我们定义了三个参数：

BRANCH_NAME: 一个字符串参数，默认值为 main。
RUN_TESTS: 一个布尔参数，默认值为 true。
ENVIRONMENT: 一个选择参数，允许用户从 dev、staging 和 production 中选择一个值。

在流水线的各个阶段中，我们可以通过 params 对象访问这些参数的值。

实际应用场景

场景1：多环境部署

假设你有一个应用程序需要在多个环境中部署（如开发、测试和生产环境）。通过参数化流水线，你可以让用户在运行流水线时选择目标环境，而不需要为每个环境创建单独的流水线。

groovy

pipeline {
    agent any
    parameters {
        choice(name: 'ENVIRONMENT', choices: ['dev', 'staging', 'production'], description: 'Select deployment environment')
    }
    stages {
        stage('Deploy') {
            steps {
                echo "Deploying to ${params.ENVIRONMENT} environment"
                // 根据环境执行不同的部署脚本
                script {
                    if (params.ENVIRONMENT == 'dev') {
                        sh './deploy-dev.sh'
                    } else if (params.ENVIRONMENT == 'staging') {
                        sh './deploy-staging.sh'
                    } else if (params.ENVIRONMENT == 'production') {
                        sh './deploy-prod.sh'
                    }
                }
            }
        }
    }
}

场景2：动态构建分支

在开发过程中，你可能需要从不同的Git分支构建代码。通过参数化流水线，你可以让用户指定要构建的分支。

groovy

pipeline {
    agent any
    parameters {
        string(name: 'BRANCH_NAME', defaultValue: 'main', description: 'Git branch to build')
    }
    stages {
        stage('Checkout') {
            steps {
                echo "Checking out branch: ${params.BRANCH_NAME}"
                git branch: "${params.BRANCH_NAME}", url: 'https://github.com/your-repo.git'
            }
        }
        stage('Build') {
            steps {
                echo "Building the application..."
                sh './build.sh'
            }
        }
    }
}

什么是 Jenkins Pipeline？ ​

Pipeline 的优势 ​

Pipeline 的基本结构 ​

Pipeline 的实际应用场景 ​

场景 1：多环境部署 ​

场景 2：并行执行任务 ​

Jenkins 声明式流水线 ​

声明式流水线的基本结构 ​

声明式流水线的关键概念 ​

1. pipeline 块 ​

2. agent 指令 ​

3. stages 块 ​

4. stage 块 ​

5. steps 块 ​

声明式流水线的实际应用场景 ​

Jenkins 脚本式流水线 ​

脚本式流水线的基本结构 ​

代码解释 ​

脚本式流水线的优势 ​

实际案例：自动化构建和部署Java应用 ​

代码解释 ​

Jenkins的Jenkinsfile ​

Jenkins file 的基本结构 ​

代码解析 ​

Jenkins file 的核心概念 ​

1. Agent ​

2. Stages 和 Steps ​

3. Environment ​

4. Post Actions ​

实际案例：构建和部署一个 Java 应用 ​

代码解析 ​

Jenkins 并行执行 ​

基本语法 ​

实际案例 ​

并行执行与依赖关系 ​

Jenkins 条件执行 ​

条件表达式的类型 ​

示例：使用 branch 条件 ​

示例：使用 allOf 和 `anyOf ​

实际案例 ​

Jenkins 参数化流水线 ​

如何定义参数化流水线 ​

实际应用场景 ​

场景1：多环境部署 ​

场景2：动态构建分支 ​

什么是 Jenkins Pipeline？

Pipeline 的优势

Pipeline 的基本结构

Pipeline 的实际应用场景

场景 1：多环境部署

场景 2：并行执行任务

Jenkins 声明式流水线

声明式流水线的基本结构

声明式流水线的关键概念

1. `pipeline` 块

2. `agent` 指令

3. `stages` 块

4. `stage` 块

5. `steps` 块

声明式流水线的实际应用场景

Jenkins 脚本式流水线

脚本式流水线的基本结构

代码解释

脚本式流水线的优势

实际案例：自动化构建和部署Java应用

代码解释

Jenkins的Jenkinsfile

Jenkins file 的基本结构

代码解析

Jenkins file 的核心概念

1. Agent

2. Stages 和 Steps

3. Environment

4. Post Actions

实际案例：构建和部署一个 Java 应用

代码解析

Jenkins 并行执行

基本语法

实际案例

并行执行与依赖关系

Jenkins 条件执行

条件表达式的类型

示例：使用 `branch` 条件

示例：使用 `allOf` 和 `anyOf

实际案例

Jenkins 参数化流水线

如何定义参数化流水线

实际应用场景

场景1：多环境部署

场景2：动态构建分支