Jenkins

日月星辰Ace2025-03-14 13:58

Jenkins 是一个开源的自动化服务器，用于持续集成和持续交付（CI/CD）。它可以帮助开发团队自动化构建、测试和部署过程，从而提高软件开发的效率和质量。

Jenkins 的基本概念

  1. 持续集成（CI） ：

    • 持续集成是一种软件开发实践，开发人员频繁地将代码集成到共享代码库中，每次集成都触发自动化构建和测试。
    • Jenkins 可以自动化这些构建和测试过程，确保每次代码更改都能快速验证。

  2. 持续交付（CD） ：

    • 持续交付是持续集成的延伸，确保代码在任何时候都可以安全地部署到生产环境。
    • Jenkins 可以自动化部署过程，确保代码在通过所有测试后自动部署到目标环境。

Jenkins 的运行机制

Jenkins 的运行机制基于以下几个关键组件：

  1. Jenkins Master：

    • Jenkins Master 是 Jenkins 的核心组件，负责协调所有构建任务。
    • 它提供用户界面，管理构建队列，分配构建任务给 Jenkins Agent，并监控构建结果。

  2. Jenkins Agent：

    • Jenkins Agent（也称为 Jenkins Slave）是执行构建任务的工作节点。
    • Jenkins Master 将构建任务分配给 Jenkins Agent，Agent 执行任务并将结果返回给 Master。

  3. Job（任务） ：

    • Job 是 Jenkins 中的基本构建单元，定义了构建、测试和部署的过程。
    • 每个 Job 包含一系列步骤（如拉取代码、编译、运行测试、部署等），这些步骤可以通过插件进行扩展。

  4. Pipeline（流水线） ：

    • Pipeline 是 Jenkins 中的高级构建单元，定义了复杂的构建、测试和部署流程。
    • Pipeline 使用 Groovy 脚本编写，支持分阶段执行、并行执行和条件执行。

Jenkins 的原理

Jenkins 的原理基于以下几个关键点：

  1. 触发机制：

    • Jenkins 可以通过多种方式触发构建任务，如代码提交、定时触发、手动触发、Webhook 等。
    • 触发机制确保每次代码更改都能自动触发构建和测试过程。

  2. 插件体系：

    • Jenkins 拥有丰富的插件体系，支持各种构建工具、版本控制系统、测试框架、部署工具等。
    • 插件体系使得 Jenkins 可以灵活地集成到各种开发环境中。

  3. 分布式构建：

    • Jenkins 支持分布式构建，可以将构建任务分配给多个 Jenkins Agent 执行。
    • 分布式构建提高了构建效率，减少了构建时间。

  4. 流水线（Pipeline） ：

    • Jenkins Pipeline 是一种基于代码的构建和部署流程定义方式，使用 Groovy 脚本编写。
    • Pipeline 支持复杂的构建流程，如分阶段执行、并行执行、条件执行等。

示例：创建一个简单的 Jenkins Job

以下是如何创建一个简单的 Jenkins Job 的步骤：

  1. 安装 Jenkins：

    • 下载并安装 Jenkins，可以在本地或服务器上运行。
    • 访问 Jenkins 的 Web 界面（默认地址是 http://localhost:8080）。

  2. 创建一个新 Job：

    • 在 Jenkins 的 Web 界面上，点击 "New Item" 创建一个新 Job。
    • 输入 Job 名称，选择 "Freestyle project" 类型，点击 "OK"。

  3. 配置 Job：

    • 在 Job 配置页面，配置源码管理（如 Git），指定代码仓库地址。
    • 配置构建触发器（如代码提交触发、定时触发等）。
    • 配置构建步骤（如执行 Shell 脚本、调用构建工具等）。

  4. 保存并构建：

    • 保存 Job 配置，点击 "Build Now" 手动触发构建。
    • 查看构建日志，检查构建结果。

示例：创建一个简单的 Jenkins Pipeline

以下是如何创建一个简单的 Jenkins Pipeline 的步骤：

  1. 创建一个新 Pipeline：

    • 在 Jenkins 的 Web 界面上，点击 "New Item" 创建一个新 Pipeline。
    • 输入 Pipeline 名称，选择 "Pipeline" 类型，点击 "OK"。

  2. 配置 Pipeline：

    • 在 Pipeline 配置页面，选择 "Pipeline script" 选项。
    • 输入 Pipeline 脚本，例如：
typescript 复制代码 
pipeline {
    agent any
    stages {
        stage('Build') {
            steps {
                echo 'Building...'
                // 执行构建步骤，如编译代码
            }
        }
        stage('Test') {
            steps {
                echo 'Testing...'
                // 执行测试步骤，如运行单元测试
            }
        }
        stage('Deploy') {
            steps {
                echo 'Deploying...'
                // 执行部署步骤，如部署到服务器
            }
        }
    }
}

  1. 保存并构建：

    • 保存 Pipeline 配置，点击 "Build Now" 手动触发构建。
    • 查看构建日志，检查构建结果。

总结

  • Jenkins 是一个开源的自动化服务器，用于持续集成和持续交付（CI/CD）。
  • Jenkins 的运行机制 基于 Jenkins Master 和 Jenkins Agent，Master 负责协调构建任务，Agent 执行构建任务。
  • Jenkins 的原理 基于触发机制、插件体系、分布式构建和流水线（Pipeline）。
  • Jenkins Job 是基本构建单元，定义了构建、测试和部署的过程。
  • Jenkins Pipeline 是高级构建单元，使用 Groovy 脚本定义复杂的构建、测试和部署流程。

Jenkins Job 和 Jenkins Pipeline 的关系是什么？他们有什么区别？我怎么理解他们是同一个东西？

Jenkins Job 和 Jenkins Pipeline 都是 Jenkins 中用于定义和执行构建、测试和部署任务的基本单元，但它们在功能和使用方式上有一些区别。以下是对 Jenkins Job 和 Jenkins Pipeline 的详细解释，以及它们之间的关系和区别。

Jenkins Job

定义
  • Jenkins Job 是 Jenkins 中的基本构建单元，用于定义一系列构建、测试和部署步骤。
  • Job 可以是简单的任务，如编译代码、运行测试、部署应用等。
类型
  • Freestyle Project：最常见的 Job 类型，提供了一个简单的用户界面来配置构建步骤。
  • Maven Project：专门用于 Maven 构建的 Job 类型，提供了对 Maven 项目的支持。
  • Multi-configuration Project：用于定义多种配置的 Job 类型，可以在不同的环境中运行相同的构建。
  • Pipeline：使用 Pipeline 脚本定义的 Job 类型，支持复杂的构建流程。
配置
  • Job 的配置通过 Jenkins 的 Web 界面完成，可以配置源码管理、构建触发器、构建步骤、构建后操作等。
  • 每个 Job 都有一个独立的配置页面，用户可以通过图形界面添加和配置构建步骤。

Jenkins Pipeline

定义
  • Jenkins Pipeline 是 Jenkins 中的高级构建单元，用于定义复杂的构建、测试和部署流程。
  • Pipeline 使用代码（通常是 Groovy 脚本）来定义构建过程，支持分阶段执行、并行执行和条件执行。
类型
  • Declarative Pipeline：一种更高级别的语法，提供了更简洁和结构化的方式来定义 Pipeline。
  • Scripted Pipeline：基于 Groovy 脚本的低级别语法，提供了更大的灵活性和控制。
配置
  • Pipeline 的配置通过编写 Pipeline 脚本完成，可以直接在 Jenkins 的 Web 界面中编写脚本，或者将脚本存储在源码管理系统中。
  • Pipeline 脚本定义了整个构建过程，包括各个阶段（stages）和步骤（steps）。

关系和区别

关系
  • Pipeline 是一种特殊类型的 Job：在 Jenkins 中，Pipeline 实际上是一个特殊类型的 Job。它使用代码来定义构建过程，而不是通过图形界面配置。
  • Job 的高级形式：Pipeline 可以看作是 Job 的高级形式，提供了更强大的功能和灵活性，适用于复杂的构建和部署流程。
区别

  1. 定义方式：

    • Job：通过 Jenkins 的 Web 界面配置，适用于简单的构建任务。
    • Pipeline：通过编写脚本定义，适用于复杂的构建和部署流程。

  2. 灵活性：

    • Job：配置简单，适用于简单的构建任务，但灵活性较低。
    • Pipeline：提供了更大的灵活性，可以定义复杂的构建流程，包括分阶段执行、并行执行和条件执行。

  3. 可维护性：

    • Job：配置通过图形界面完成，配置项较多时可能难以维护。
    • Pipeline：通过代码定义，构建过程可以版本控制，更易于维护和共享。

示例

Jenkins Job 示例
arduino 复制代码 
// 在 Jenkins 的 Web 界面上配置一个 Freestyle Project
// 配置源码管理、构建触发器、构建步骤等
Jenkins Pipeline 示例
typescript 复制代码 
pipeline {
    agent any
    stages {
        stage('Build') {
            steps {
                echo 'Building...'
                // 执行构建步骤，如编译代码
            }
        }
        stage('Test') {
            steps {
                echo 'Testing...'
                // 执行测试步骤，如运行单元测试
            }
        }
        stage('Deploy') {
            steps {
                echo 'Deploying...'
                // 执行部署步骤，如部署到服务器
            }
        }
    }
}

总结

  • Jenkins Job 是 Jenkins 中的基本构建单元，通过图形界面配置，适用于简单的构建任务。
  • Jenkins Pipeline 是 Jenkins 中的高级构建单元，通过编写脚本定义，适用于复杂的构建和部署流程。
  • 关系：Pipeline 是一种特殊类型的 Job，提供了更强大的功能和灵活性。
  • 区别：Job 通过图形界面配置，Pipeline 通过代码定义，Pipeline 提供了更大的灵活性和可维护性。

when { expression { return params.Refresh_Parameters == 'Yes' || params.Refresh_Parameters == null } } 帮我解释下这段代码

这段代码是 Jenkins Pipeline 中的一个条件语句，用于在 Pipeline 脚本中根据某个条件来决定是否执行某些步骤。具体来说，这段代码使用了 when 块来定义一个条件，只有在条件为 true 时，相关的步骤才会被执行。

解释

csharp 复制代码 
when {
    expression {
        return params.Refresh_Parameters == 'Yes' || params.Refresh_Parameters == null
    }
}
1. when 块
  • when 块 ：when 块用于在 Jenkins Pipeline 中定义条件执行。它可以包含多种条件，如 branch、expression、environment 等。
  • 作用 ：when 块中的条件决定了某个阶段（stage）或步骤（step）是否会被执行。
2. expression 块
  • expression 块 ：expression 块用于定义一个自定义的 Groovy 表达式作为条件。
  • 作用 ：expression 块中的表达式会被求值，如果结果为 true，则相关的阶段或步骤会被执行；如果结果为 false，则相关的阶段或步骤会被跳过。
3. 表达式

  • 表达式 ：return params.Refresh_Parameters == 'Yes' || params.Refresh_Parameters == null

  • 作用 ：这个表达式检查 Jenkins Pipeline 参数 Refresh_Parameters 的值。

    • 如果 Refresh_Parameters 的值为 'Yes'，表达式返回 true。
    • 如果 Refresh_Parameters 的值为 null，表达式返回 true。
    • 否则，表达式返回 false。

示例

以下是一个完整的 Jenkins Pipeline 示例，展示了如何使用 when 块和 expression 块来条件执行某个阶段：

typescript 复制代码 
pipeline {
    agent any
    parameters {
        string(name: 'Refresh_Parameters', defaultValue: 'No', description: 'Should parameters be refreshed?')
    }
    stages {
        stage('Build') {
            steps {
                echo 'Building...'
                // 执行构建步骤，如编译代码
            }
        }
        stage('Conditional Stage') {
            when {
                expression {
                    return params.Refresh_Parameters == 'Yes' || params.Refresh_Parameters == null
                }
            }
            steps {
                echo 'Refreshing parameters...'
                // 执行刷新参数的步骤
            }
        }
        stage('Test') {
            steps {
                echo 'Testing...'
                // 执行测试步骤，如运行单元测试
            }
        }
    }
}

解释

  1. 参数定义：

    • parameters 块定义了一个名为 Refresh_Parameters 的字符串参数，默认值为 'No'。
    • 用户可以在构建时指定这个参数的值。

  2. Build 阶段：

    • Build 阶段包含构建步骤，无条件执行。

  3. Conditional Stage 阶段：

    • when 块中的 expression 块定义了一个条件，检查 Refresh_Parameters 的值。
    • 如果 Refresh_Parameters 的值为 'Yes' 或 null，则执行 Conditional Stage 阶段中的步骤。
    • 否则，跳过 Conditional Stage 阶段。

  4. Test 阶段：

    • Test 阶段包含测试步骤，无条件执行。

总结

  • when 块：用于在 Jenkins Pipeline 中定义条件执行。
  • expression 块：用于定义一个自定义的 Groovy 表达式作为条件。
  • 表达式 ：检查 Jenkins Pipeline 参数 Refresh_Parameters 的值，如果为 'Yes' 或 null，则返回 true，否则返回 false。

Jenkinsfile 的语法结构

Jenkinsfile 是 Jenkins Pipeline 的脚本文件，用于定义 Jenkins Pipeline 的构建、测试和部署流程。Jenkinsfile 使用 Groovy 语言编写，支持声明式语法和脚本式语法。你提供的 Jenkinsfile 使用的是声明式语法，它提供了一种更简洁和结构化的方式来定义 Pipeline。

Jenkinsfile 的语法结构

以下是对你提供的 Jenkinsfile 的详细讲解：

typescript 复制代码 
pipeline {
    agent any

    stages {
        stage('A') {
            when {
                expression {
                    // 条件表达式
                }
            }
            steps {
                script {
                    // 构建步骤
                }
            }
        }
        stage('B') {
            when {
                expression {
                    // 条件表达式
                }
            }
            steps {
                script {
                    // 构建步骤
                }
            }
        }
    }
}

主要部分解释

1. pipeline 块
  • pipeline 块：这是声明式 Pipeline 的顶级块，包含整个 Pipeline 的定义。
  • 作用：定义 Pipeline 的整体结构，包括代理、阶段和步骤。
2. agent 块
  • agent 块：指定在哪个节点上执行 Pipeline 或阶段。
  • any：表示可以在任何可用的 Jenkins Agent 上执行。
3. stages 块
  • stages 块：包含一个或多个阶段（stage），每个阶段代表构建过程中的一个逻辑单元。
  • 作用：定义 Pipeline 中的各个阶段，每个阶段可以包含多个步骤。
4. stage 块
  • stage 块：定义一个阶段，包含阶段的名称、条件和步骤。
  • stage('A') 和 stage('B') ：定义了两个阶段，分别命名为 'A' 和 'B'。
5. when 块
  • when 块：定义条件，决定是否执行该阶段。
  • expression 块 ：使用自定义的 Groovy 表达式作为条件，表达式返回 true 时执行该阶段，返回 false 时跳过该阶段。
6. steps 块
  • steps 块：包含一个或多个步骤（step），每个步骤代表构建过程中的一个具体操作。
  • script 块：包含 Groovy 脚本，可以执行任意的 Groovy 代码。

示例代码

以下是一个完整的示例代码，展示了如何使用 Jenkinsfile 定义一个简单的 Pipeline：

typescript 复制代码 
pipeline {
    agent any

    stages {
        stage('Build') {
            when {
                expression {
                    return params.BUILD == 'true'
                }
            }
            steps {
                script {
                    echo 'Building...'
                    // 执行构建步骤，如编译代码
                }
            }
        }
        stage('Test') {
            when {
                expression {
                    return params.TEST == 'true'
                }
            }
            steps {
                script {
                    echo 'Testing...'
                    // 执行测试步骤，如运行单元测试
                }
            }
        }
        stage('Deploy') {
            when {
                expression {
                    return params.DEPLOY == 'true'
                }
            }
            steps {
                script {
                    echo 'Deploying...'
                    // 执行部署步骤，如部署到服务器
                }
            }
        }
    }
}

解释

  1. 参数定义：

    • 在 Jenkins 的 Web 界面上，可以定义参数 BUILD、TEST 和 DEPLOY，用于控制各个阶段的执行。

  2. Build 阶段：

    • when 块中的 expression 块检查参数 BUILD 是否为 'true'。
    • 如果条件为 true，执行构建步骤；否则，跳过该阶段。

  3. Test 阶段：

    • when 块中的 expression 块检查参数 TEST 是否为 'true'。
    • 如果条件为 true，执行测试步骤；否则，跳过该阶段。

  4. Deploy 阶段：

    • when 块中的 expression 块检查参数 DEPLOY 是否为 'true'。
    • 如果条件为 true，执行部署步骤；否则，跳过该阶段。

总结

  • pipeline 块：定义整个 Pipeline 的结构。
  • agent 块：指定在哪个节点上执行 Pipeline 或阶段。
  • stages 块：包含一个或多个阶段，每个阶段代表构建过程中的一个逻辑单元。
  • stage 块：定义一个阶段，包含阶段的名称、条件和步骤。
  • when 块：定义条件，决定是否执行该阶段。
  • steps 块：包含一个或多个步骤，每个步骤代表构建过程中的一个具体操作。
  • script 块：包含 Groovy 脚本，可以执行任意的 Groovy 代码。

脚本式语法的 example

Jenkinsfile 可以使用两种主要的语法来编写：声明式语法和脚本式语法。你之前提供的例子是声明式语法。现在，我将为你提供一个脚本式语法的示例。

脚本式语法

脚本式语法（Scripted Syntax）提供了更大的灵活性和控制，允许你使用 Groovy 语言编写更复杂的构建逻辑。脚本式语法使用 node 块来定义构建节点，并通过 stage 和 steps 来定义构建过程。

示例代码

以下是一个使用脚本式语法编写的 Jenkinsfile 示例：

javascript 复制代码 
node {
    // 定义参数
    def build = params.BUILD ?: 'true'
    def test = params.TEST ?: 'true'
    def deploy = params.DEPLOY ?: 'true'

    // Checkout 代码
    stage('Checkout') {
        checkout scm
    }

    // 构建阶段
    if (build == 'true') {
        stage('Build') {
            echo 'Building...'
            // 执行构建步骤，如编译代码
            sh 'echo Building the project...'
        }
    }

    // 测试阶段
    if (test == 'true') {
        stage('Test') {
            echo 'Testing...'
            // 执行测试步骤，如运行单元测试
            sh 'echo Running tests...'
        }
    }

    // 部署阶段
    if (deploy == 'true') {
        stage('Deploy') {
            echo 'Deploying...'
            // 执行部署步骤，如部署到服务器
            sh 'echo Deploying the project...'
        }
    }
}

解释

  1. node 块：

    • node 块定义了构建节点，所有的构建步骤都在这个节点上执行。
    • 在脚本式语法中，node 块是顶级块，类似于声明式语法中的 pipeline 块。

  2. 参数定义：

    • 使用 params 对象获取 Jenkins 参数，并提供默认值。
    • 例如，def build = params.BUILD ?: 'true' 表示如果参数 BUILD 未定义，则使用默认值 'true'。

  3. stage 块：

    • stage 块定义了构建过程中的一个逻辑单元，每个阶段包含一组构建步骤。
    • 例如，stage('Build') 定义了一个名为 "Build" 的阶段。

  4. 条件执行：

    • 使用 if 语句根据参数值决定是否执行某个阶段。
    • 例如，if (build == 'true') 表示只有当参数 BUILD 的值为 'true' 时，才执行 "Build" 阶段。

  5. 构建步骤：

    • 使用 echo 和 sh 命令定义具体的构建步骤。
    • 例如，sh 'echo Building the project...' 表示执行一个 Shell 命令。

总结

  • 脚本式语法 提供了更大的灵活性和控制，允许你使用 Groovy 语言编写更复杂的构建逻辑。
  • node 块 定义了构建节点，所有的构建步骤都在这个节点上执行。
  • stage 块 定义了构建过程中的一个逻辑单元，每个阶段包含一组构建步骤。
  • 条件执行 使用 if 语句根据参数值决定是否执行某个阶段。
  • 构建步骤 使用 echo 和 sh 命令定义具体的构建步骤。

脚本式语法是用 node 写的吗？还是 Groovy 写的？

脚本式语法（Scripted Syntax）是使用 Groovy 语言编写的，并且在 Jenkins Pipeline 中通常使用 node 块来定义构建节点。node 块是脚本式语法的核心部分，用于指定在哪个 Jenkins Agent 上执行构建任务。

脚本式语法的基本结构

脚本式语法使用 Groovy 语言编写，允许你编写更复杂和灵活的构建逻辑。以下是脚本式语法的基本结构：

javascript 复制代码 
node {
    // 在这里定义构建逻辑
    stage('Stage Name') {
        steps {
            // 构建步骤
        }
    }
}

示例代码

以下是一个完整的脚本式语法的 Jenkinsfile 示例，展示了如何使用 node 块和 Groovy 语言编写构建逻辑：

javascript 复制代码 
node {
    // 定义参数
    def build = params.BUILD ?: 'true'
    def test = params.TEST ?: 'true'
    def deploy = params.DEPLOY ?: 'true'

    // Checkout 代码
    stage('Checkout') {
        checkout scm
    }

    // 构建阶段
    if (build == 'true') {
        stage('Build') {
            echo 'Building...'
            // 执行构建步骤，如编译代码
            sh 'echo Building the project...'
        }
    }

    // 测试阶段
    if (test == 'true') {
        stage('Test') {
            echo 'Testing...'
            // 执行测试步骤，如运行单元测试
            sh 'echo Running tests...'
        }
    }

    // 部署阶段
    if (deploy == 'true') {
        stage('Deploy') {
            echo 'Deploying...'
            // 执行部署步骤，如部署到服务器
            sh 'echo Deploying the project...'
        }
    }
}

解释

  1. node 块：

    • node 块定义了构建节点，所有的构建步骤都在这个节点上执行。
    • 在脚本式语法中，node 块是顶级块，类似于声明式语法中的 pipeline 块。

  2. 参数定义：

    • 使用 params 对象获取 Jenkins 参数，并提供默认值。
    • 例如，def build = params.BUILD ?: 'true' 表示如果参数 BUILD 未定义，则使用默认值 'true'。

  3. stage 块：

    • stage 块定义了构建过程中的一个逻辑单元，每个阶段包含一组构建步骤。
    • 例如，stage('Build') 定义了一个名为 "Build" 的阶段。

  4. 条件执行：

    • 使用 if 语句根据参数值决定是否执行某个阶段。
    • 例如，if (build == 'true') 表示只有当参数 BUILD 的值为 'true' 时，才执行 "Build" 阶段。

  5. 构建步骤：

    • 使用 echo 和 sh 命令定义具体的构建步骤。
    • 例如，sh 'echo Building the project...' 表示执行一个 Shell 命令。

总结

  • 脚本式语法：使用 Groovy 语言编写，提供了更大的灵活性和控制，适用于复杂的构建逻辑。
  • node 块：定义构建节点，所有的构建步骤都在这个节点上执行。
  • stage 块：定义构建过程中的一个逻辑单元，每个阶段包含一组构建步骤。
  • 条件执行 ：使用 if 语句根据参数值决定是否执行某个阶段。
  • 构建步骤 ：使用 echo 和 sh 命令定义具体的构建步骤。

node 块：定义构建节点，相当于声明式里的 agent 吗？

是的，在 Jenkins Pipeline 中，脚本式语法中的 node 块与声明式语法中的 agent 块具有类似的功能。它们都用于指定在哪个 Jenkins Agent 上执行构建任务。以下是对这两者的详细解释和比较。

声明式语法中的 agent 块

在声明式语法中，agent 块用于指定整个 Pipeline 或特定阶段（stage）在哪个 Jenkins Agent 上执行。agent 块可以有多种配置方式，如 any、none、label 等。

示例
typescript 复制代码 
pipeline {
    agent any

    stages {
        stage('Build') {
            agent {
                label 'linux'
            }
            steps {
                echo 'Building on a Linux agent...'
            }
        }
        stage('Test') {
            steps {
                echo 'Testing...'
            }
        }
    }
}

脚本式语法中的 node 块

在脚本式语法中，node 块用于指定构建任务在哪个 Jenkins Agent 上执行。node 块可以包含多个阶段（stage）和步骤（steps）。node 块的参数可以是 Agent 的标签，类似于声明式语法中的 agent 块。

示例
javascript 复制代码 
node('linux') {
    stage('Build') {
        echo 'Building on a Linux agent...'
        // 执行构建步骤
    }
    stage('Test') {
        echo 'Testing...'
        // 执行测试步骤
    }
}

比较

相似点

  1. 指定执行环境：

    • agent 块：在声明式语法中用于指定整个 Pipeline 或特定阶段在哪个 Jenkins Agent 上执行。
    • node 块：在脚本式语法中用于指定构建任务在哪个 Jenkins Agent 上执行。

  2. 灵活性：

    • agent 块：可以在 Pipeline 级别或阶段级别指定 Agent。
    • node 块：可以在任意位置使用，灵活地指定不同的 Agent。
不同点

  1. 语法和使用方式：

    • 声明式语法 ：使用 agent 块，语法更结构化，适用于简单和中等复杂度的 Pipeline。
    • 脚本式语法 ：使用 node 块，语法更灵活，适用于复杂的构建逻辑。

  2. 配置方式：

    • agent 块 ：可以使用 any、none、label 等多种配置方式。
    • node 块：通常使用标签来指定 Agent，但也可以使用其他方式。

示例对比

声明式语法
typescript 复制代码 
pipeline {
    agent any

    stages {
        stage('Build') {
            agent {
                label 'linux'
            }
            steps {
                echo 'Building on a Linux agent...'
                // 执行构建步骤
            }
        }
        stage('Test') {
            steps {
                echo 'Testing...'
                // 执行测试步骤
            }
        }
    }
}
脚本式语法
javascript 复制代码 
node('linux') {
    stage('Build') {
        echo 'Building on a Linux agent...'
        // 执行构建步骤
    }
    stage('Test') {
        echo 'Testing...'
        // 执行测试步骤
    }
}

总结

  • agent 块：在声明式语法中用于指定整个 Pipeline 或特定阶段在哪个 Jenkins Agent 上执行，语法更结构化。
  • node 块：在脚本式语法中用于指定构建任务在哪个 Jenkins Agent 上执行，语法更灵活。
  • 相似点：都用于指定执行环境，确保构建任务在指定的 Jenkins Agent 上执行。
  • 不同点：语法和使用方式不同，声明式语法更结构化，脚本式语法更灵活。

什么时候使用声明式语法，什么时候使用脚本式语法？

选择使用声明式语法还是脚本式语法取决于你的项目需求、团队的熟悉程度以及构建流程的复杂性。以下是一些指导原则，帮助你决定何时使用声明式语法，何时使用脚本式语法。

声明式语法

适用场景

  1. 简单和中等复杂度的 Pipeline：

    • 如果你的构建流程相对简单或中等复杂度，声明式语法通常是更好的选择。它提供了结构化的语法，使得 Pipeline 更易于阅读和维护。

  2. 团队成员不熟悉 Groovy：

    • 如果团队成员对 Groovy 语言不熟悉，声明式语法更容易上手。它提供了更高层次的抽象，减少了编写复杂脚本的需求。

  3. 标准化和一致性：

    • 声明式语法强制使用特定的结构，有助于在团队中保持一致的 Pipeline 风格和标准化。

  4. 快速入门：

    • 对于新项目或新团队，声明式语法提供了更快的入门路径。它的语法更接近于配置文件，易于理解和使用。
示例
typescript 复制代码 
pipeline {
    agent any

    stages {
        stage('Build') {
            steps {
                echo 'Building...'
                // 执行构建步骤
            }
        }
        stage('Test') {
            steps {
                echo 'Testing...'
                // 执行测试步骤
            }
        }
        stage('Deploy') {
            steps {
                echo 'Deploying...'
                // 执行部署步骤
            }
        }
    }
}

脚本式语法

适用场景

  1. 复杂的构建流程：

    • 如果你的构建流程非常复杂，需要高度自定义的逻辑，脚本式语法提供了更大的灵活性和控制。你可以使用 Groovy 语言编写任意复杂的构建逻辑。

  2. 需要动态行为：

    • 当构建流程需要动态行为（如动态生成阶段、条件执行复杂逻辑等），脚本式语法更适合。它允许你在 Pipeline 中编写复杂的条件和循环。

  3. 团队熟悉 Groovy：

    • 如果团队成员熟悉 Groovy 语言，脚本式语法可以充分利用 Groovy 的强大功能，编写更灵活和强大的 Pipeline。

  4. 现有脚本迁移：

    • 如果你有现有的 Groovy 脚本或需要与其他 Groovy 代码集成，脚本式语法是更自然的选择。
示例
javascript 复制代码 
node {
    // 定义参数
    def build = params.BUILD ?: 'true'
    def test = params.TEST ?: 'true'
    def deploy = params.DEPLOY ?: 'true'

    // Checkout 代码
    stage('Checkout') {
        checkout scm
    }

    // 构建阶段
    if (build == 'true') {
        stage('Build') {
            echo 'Building...'
            // 执行构建步骤，如编译代码
            sh 'echo Building the project...'
        }
    }

    // 测试阶段
    if (test == 'true') {
        stage('Test') {
            echo 'Testing...'
            // 执行测试步骤，如运行单元测试
            sh 'echo Running tests...'
        }
    }

    // 部署阶段
    if (deploy == 'true') {
        stage('Deploy') {
            echo 'Deploying...'
            // 执行部署步骤，如部署到服务器
            sh 'echo Deploying the project...'
        }
    }
}

比较

声明式语法

  • 优点：

    • 结构化语法，易于阅读和维护。
    • 强制使用特定的结构，有助于标准化。
    • 更快的入门路径，适合不熟悉 Groovy 的团队。

  • 缺点：

    • 灵活性较低，不适合非常复杂的构建逻辑。
    • 动态行为支持有限。
脚本式语法

  • 优点：

    • 提供更大的灵活性和控制，适合复杂的构建流程。
    • 支持动态行为和复杂逻辑。
    • 适合熟悉 Groovy 的团队。

  • 缺点：

    • 语法复杂，可能难以阅读和维护。
    • 需要团队成员熟悉 Groovy 语言。

总结

  • 使用声明式语法：当你的构建流程相对简单或中等复杂度，团队成员不熟悉 Groovy，或者你希望快速入门并保持标准化时，选择声明式语法。
  • 使用脚本式语法：当你的构建流程非常复杂，需要高度自定义的逻辑，团队成员熟悉 Groovy，或者你需要动态行为时，选择脚本式语法。
相关推荐
遨游DATA1 天前
Jenkins 修改 config.xml 后页面仍是旧配置：让 live job 配置真正生效
ci/cd·jenkins·devops·故障排查·config.xml
Dobby_051 天前
【CICD】Jenkins Pipeline 快速学习入门
运维·学习·jenkins
上海安当技术2 天前
统一身份认证平台怎么落地？11 个异构业务系统接入 ASP 的完整实施路径
数据库·servlet·架构·kubernetes·jenkins
回眸不遇3 天前
Elasticsearch嵌套类型nested使用指南
大数据·elasticsearch·jenkins
回眸不遇4 天前
类型的区别和应用场景 nested 每个对象独立存储为隐藏的子文档 适合存储数组 查询的时候有特定的语法 nested查询 且字段要 ...
运维·jenkins
X1A0RAN5 天前
容器化部署 Jenkins 教程
运维·docker·jenkins
BullSmall5 天前
jenkins 全局工具变更后，构建的任务为什么没有刷新过来
运维·jenkins
BullSmall5 天前
报错 libatomic.so.1: No such file or directory
jenkins
ji_shuke6 天前
从零深入：基于 Playwright + Pytest + Allure 的企业级 Web 端到端自动化测试框架实战
前端·自动化测试·docker·jenkins·pytest·allure·playwright
上海安当技术6 天前
老系统零改造接入：旁路代理统一认证实战
java·servlet·架构·kubernetes·jenkins
热门推荐
01如何新建文件夹？ 电脑新建文件夹的4种方法02GitHub 镜像站点03国内可直接用、免费额度/永久免费的大模型API清单（含 SiliconFlow、火山、阿里、智谱、百度、Kimi、DeepSeek、DMXAPI 等）04Agnes AI 免费 API 接入指南：文本、生图、生视频，一套接口全免费05微信历史版本含下载地址（ Windows PC | 安卓 | MAC ）及设置微信不更新06AI 编程 IDE 全景解析 2026：Agent 全面接管开发链路072026 国产 AI 大模型横评：DeepSeek、通义千问、Kimi、文心一言、星火、豆包谁更能打？082026年7月AI圈大地震：GPT-5.6被政府限制、Claude入驻Slack、Anthropic自研芯片0900 Debian字符界面如何支持中文10历年考研数学一、数学二、数学三真题试卷及答案PDF