Jenkins 流水线（Pipeline）是一种持续集成和交付（CI/CD）工具，它以代码的方式定义整个软件开发过程中的构建、测试和部署流程。与传统的 Jenkins 项目和自由风格项目相比，Jenkins 流水线具有以下显著特点和优势：

1. 可编排性（Orchestration）： 流水线允许用户通过编写脚本来定义软件开发过程中的整个流程，包括构建、测试、部署等环节的顺序和依赖关系，实现了对整个流程的可编排性和可控性。

2. 可追溯性（Traceability）： 流水线通过将整个软件开发过程的定义存储在版本控制系统中，实现了对每一次构建的全面追踪和记录，包括每个阶段的执行结果、日志输出等信息，方便用户进行问题排查和分析。

3. 可重用性（Reusability）： 流水线通过提供一系列的 Pipeline DSL（Domain-Specific Language）来定义流水线的各个阶段和任务，使得用户可以编写可重用的模块和函数，方便流水线的复用和扩展。

4. 可视化（Visualization）： 流水线提供了直观的可视化界面来展示流水线的执行过程和结果，包括阶段的执行状态、耗时、触发原因等信息，方便用户实时监控和管理流水线的运行情况。

5. 灵活性（Flexibility）： 流水线允许用户根据具体的需求和场景定制和调整流水线的配置，包括添加、删除、修改阶段和任务，调整触发条件和参数配置等，实现了对流水线的灵活性和定制性。

Jenkins 流水线为软件开发团队提供了一种灵活、可控、可视化的持续集成和交付解决方案，帮助团队更好地管理和优化软件开发过程，提高开发效率和质量。

一、Pipeline 插件

Pipeline 插件是 Jenkins 中用于创建和管理流水线的核心插件，它提供了一种强大而灵活的方式来定义整个软件开发过程中的构建、测试和部署流程。

1、插件安装

Pipeline 插件是 Jenkins 的默认安装插件之一，通常在安装 Jenkins 后就会自动包含。如果你的 Jenkins 没有安装 Pipeline 插件，可以通过 Jenkins 管理界面的插件管理功能进行安装。

2、Pipeline DSL

Pipeline 插件引入了一种名为 Pipeline DSL（Domain-Specific Language）的脚本语言，它是基于 Groovy 语言的，并提供了一系列关键字和语法来定义流水线的各个阶段和任务。Pipeline DSL 主要包括以下几个核心概念：

• pipeline：定义整个流水线的入口，包括流水线的名称、参数、触发条件等信息。

• stage：定义流水线的一个阶段，包括阶段的名称、任务、并行执行等信息。

• step：定义流水线的一个任务，可以是构建、测试、部署等操作。

• node：指定流水线的执行节点，可以是 Jenkins 主节点或者代理节点。

• agent：指定流水线的代理节点，即流水线的执行环境。

• parameters：定义流水线的参数，可以在流水线执行时传入不同的参数值。

3、Pipeline 编写

编写 Pipeline 脚本通常分为以下几个步骤：

1. 定义流水线：使用 pipeline 关键字定义流水线，并设置流水线的参数和触发条件。

2. 定义阶段：使用 stage 关键字定义流水线的各个阶段，并设置阶段的名称和任务。

3. 编写任务：在每个阶段中使用 steps 或其他任务相关的关键字来编写具体的任务脚本，如构建、测试、部署等。

4. 设置代理节点：如果需要在特定的节点上执行任务，可以使用 agent 或 node 关键字来设置执行节点。

5. 参数化：如果流水线需要接受外部参数，可以使用 parameters 关键字定义参数列表，并在流水线执行时传入参数值。

4、示例

下面是一个简单的 Pipeline 脚本示例，演示了一个简单的构建和测试流水线：

1. pipeline {

2.     agent any

3.     

4.     stages {

5.         stage('Build') {

6.             steps {

7.                 sh 'mvn clean package'

8.             }

9.         }

10.         stage('Test') {

11.             steps {

12.                 sh 'mvn test'

13.             }

14.         }

15.     }

16. }

以上示例定义了一个包含两个阶段（Build 和 Test）的流水线，其中 Build 阶段用于执行 Maven 构建，Test 阶段用于执行 Maven 测试。这个示例演示了如何使用 Pipeline 插件来创建和管理流水线，以及如何编写简单的 Pipeline 脚本来定义流水线的各个阶段和任务。

二、Pipeline 脚本语法

Pipeline 脚本语法是 Pipeline 插件提供的一种特定语法，用于编写 Jenkins 流水线的各个阶段和任务。

1、Stage（阶段）

Stage 是流水线中的一个逻辑单元，用于将流水线划分为不同的阶段，如构建、测试、部署等。

使用 stage 关键字定义一个阶段，并指定阶段的名称。

1. pipeline {

2.     agent any

3.     stages {

4.         stage('Build') {

5.             steps {

6.                 // 构建步骤

7.             }

8.         }

9.         stage('Test') {

10.             steps {

11.                 // 测试步骤

12.             }

13.         }

14.         // 更多阶段...

15.     }

16. }

 

2、Step（步骤）

Step 是流水线执行的最小单元，用于执行具体的任务，如构建项目、运行测试、发送通知等。

使用不同的关键字或函数来定义一个步骤，如 sh（执行 Shell 命令）、echo（输出信息）、git（Git 操作）等。

1. pipeline {

2.     agent any

3.     stages {

4.         stage('Build') {

5.             steps {

6.                 sh 'mvn clean package'

7.             }

8.         }

9.         stage('Test') {

10.             steps {

11.                 echo 'Running unit tests...'

12.                 sh 'mvn test'

13.             }

14.         }

15.         // 更多步骤...

16.     }

17. }

3、Parallel（并行执行）

Parallel 允许将多个步骤或阶段并行执行，以提高流水线的执行效率。

使用 parallel 关键字将多个步骤或阶段包裹起来，并在其中定义需要并行执行的任务。

1. pipeline {

2.     agent any

3.     stages {

4.         stage('Test') {

5.             parallel {

6.                 stage('Unit Tests') {

7.                     steps {

8.                         // 执行单元测试

9.                     }

10.                 }

11.                 stage('Integration Tests') {

12.                     steps {

13.                         // 执行集成测试

14.                     }

15.                 }

16.             }

17.         }

18.     }

19. }

4、Node（节点）

Node 用于指定流水线的执行节点，即流水线的执行环境，可以是 Jenkins 主节点或代理节点。

使用 node 或 agent 关键字指定执行节点，并在其中定义流水线的各个阶段和任务。

1. pipeline {

2.     agent {

3.         label 'my-agent' // 指定代理节点

4.     }

5.     stages {

6.         stage('Build') {

7.             steps {

8.                 // 构建步骤

9.             }

10.         }

11.         // 更多阶段...

12.     }

13. }

三、流水线基础

在 Jenkins 中创建简单的流水线通常涉及以下几个步骤：定义流水线的结构、设置环境变量、编写脚本以及运行流水线。

1、定义流水线结构

首先需要定义流水线的结构，包括流水线的名称、代理节点、阶段和步骤等。

下面是一个简单的流水线定义示例，包括了一个构建阶段和一个测试阶段。

1. pipeline {

2.     agent any// 使用任意可用的代理节点

4.     stages {

5.         stage('Build') { // 定义构建阶段

6.             steps {

7.                 echo 'Building...'

8.                 sh 'make build'

9.             }

10.         }

11.         stage('Test') { // 定义测试阶段

12.             steps {

13.                 echo 'Testing...'

14.                 sh 'make test'

15.             }

16.         }

17.     }

18. }

2、设置环境变量

可以在流水线中设置环境变量，用于在流水线执行过程中传递参数、配置选项等。

下面示例演示了如何设置一个环境变量并在流水线的步骤中使用。

1. pipeline {

2.     agent any

4.     environment {

5.         NAME = 'John' // 设置一个环境变量

6.     }

8.     stages {

9.         stage('Print') {

10.             steps {

11.                 echo "Hello, ${NAME}!" // 使用环境变量

12.             }

13.         }

14.     }

15. }

3、编写流水线脚本

在流水线的各个阶段中编写脚本来实现具体的构建、测试、部署等任务。

下面示例展示了一个简单的流水线，其中包括了一个构建阶段和一个测试阶段，并在每个阶段中执行了一些命令。

1. pipeline {

2.     agent any

4.     stages {

5.         stage('Build') {

6.             steps {

7.                 echo 'Building...'

8.                 sh 'make build'

9.             }

10.         }

11.         stage('Test') {

12.             steps {

13.                 echo 'Testing...'

14.                 sh 'make test'

15.             }

16.         }

17.     }

18. }

4、运行流水线

在 Jenkins 中，可以通过在 Jenkins 界面上选择相应的流水线项目并点击“构建”按钮来手动触发流水线的执行。也可以通过配置触发器来实现自动触发流水线的执行，如定时触发、代码提交触发等。

手动触发流水线的执行通常在 Jenkins 界面上进行，点击流水线项目的“构建”按钮即可。自动触发流水线的执行需要在流水线项目的配置中配置相应的触发器，如下：

1. pipeline {

2.     triggers {

3.         cron('H/5 * * * *') // 每隔 5 分钟触发一次流水线执行

4.     }

5.     ...

6. }

四、流水线高级特性

在 Jenkins 中，流水线不仅可以实现简单的构建和测试任务，还可以利用一些高级特性来增强流水线的灵活性、可维护性和扩展性。下面详细介绍几种流水线的高级特性，并提供相应的示例代码。

1、参数化构建

参数化构建允许在流水线执行时传递参数值，使得流水线具有更大的灵活性。

下面是一个示例，演示了如何定义一个参数化的流水线，其中包括一个字符串类型的参数 ENVIRONMENT，用于指定环境名称。

1. pipeline {

2.     parameters {

3.         string(name: 'ENVIRONMENT', defaultValue: 'production', description: 'Environment name')

4.     }

5.     agent any

6.     stages {

7.         stage('Build') {

8.             steps {

9.                 echo "Building for environment: ${params.ENVIRONMENT}"

10.             }

11.         }

12.     }

13. }

2、流水线共享库

流水线共享库允许将常用的流水线代码封装为可复用的库，并在多个流水线项目中共享和引用。

创建一个名为 vars 的目录，并在其中编写一个 Groovy 脚本文件（如 utils.groovy），定义一个名为 sayHello 的全局函数，然后在流水线脚本中引用该函数：

1. // vars/utils.groovy

2. def call() {

3.     echo 'Hello, world!'

4. }

1. // Jenkinsfile

2. @Library('my-shared-library') _

3. pipeline {

4.     agent any

5.     stages {

6.         stage('Test') {

7.             steps {

8.                 utils.sayHello()

9.             }

10.         }

11.     }

12. }

3、异常处理

异常处理允许在流水线执行过程中捕获和处理异常情况，以实现更健壮的流水线。

下面示例展示了如何使用 try-catch 块来捕获异常，并在出现异常时执行相应的处理逻辑。

1. pipeline {

2.     agent any

3.     stages {

4.         stage('Deploy') {

5.             steps {

6.                 script {

7.                     try {

8.                         sh 'deploy.sh'

9.                     } catch (Exception e) {

10.                         echo "Failed to deploy: ${e.message}"

11.                         currentBuild.result = 'FAILURE'

12.                     }

13.                 }

14.             }

15.         }

16.     }

17. }

4、日志记录

日志记录允许在流水线执行过程中输出自定义的日志信息，以便在 Jenkins 界面中查看流水线的执行日志。

下面示例展示了如何使用 echo 函数输出自定义的日志信息。

1. pipeline {

2.     agent any

3.     stages {

4.         stage('Build') {

5.             steps {

6.                 echo 'Building...'

7.                 sh 'make build'

8.             }

9.         }

10.     }

11. }

五、与源代码管理集成

将流水线与版本控制系统（如 Git、SVN 等）集成可以实现当代码发生变更时自动触发流水线的执行，从而实现持续集成和持续交付。

1、Git 集成

Git 是目前最流行的版本控制系统之一，在 Jenkins 中配置 Git 集成可以实现当代码提交或分支变更时自动触发流水线的执行。

下面是一个简单的流水线配置示例，其中包括了 Git 集成，使用了 checkout 步骤来拉取代码并切换到指定分支。

1. pipeline {

2.     agent any

3.     stages {

4.         stage('Checkout') {

5.             steps {

6.                 checkout([$class: 'GitSCM', branches: [[name: 'master']], userRemoteConfigs: [[url: 'https://github.com/myuser/myrepo.git']]])

7.             }

8.         }

9.         stage('Build') {

10.             steps {

11.                 sh 'make build'

12.             }

13.         }

14.     }

15. }

2、SVN 集成

SVN 是另一种常用的版本控制系统，与 Git 类似，通过配置 SVN 集成可以实现当代码提交或分支变更时自动触发流水线的执行。

下面是一个简单的流水线配置示例，其中包括了 SVN 集成，使用了 checkout 步骤来拉取代码并切换到指定路径。

1. pipeline {

2.     agent any

3.     stages {

4.         stage('Checkout') {

5.             steps {

6.                 svn 'https://svn.example.com/svn/repo/trunk'

7.             }

8.         }

9.         stage('Build') {

10.             steps {

11.                 sh 'make build'

12.             }

13.         }

14.     }

15. }

3、高级配置

除了简单的拉取代码外，还可以配置更多高级选项，如指定分支、拉取代码的深度、使用认证信息等。

例如：

1. pipeline {

2.     agent any

3.     stages {

4.         stage('Checkout') {

5.             steps {

6.                 git branch: 'main', credentialsId: 'my-git-credentials', url: 'https://github.com/myuser/myrepo.git'

7.             }

8.         }

9.         // 其他阶段...

10.     }

11. }

六、与测试框架集成

将流水线与测试框架集成可以实现自动执行测试并生成测试报告，从而实现持续集成和持续交付。

1、JUnit 集成

JUnit 是 Java 平台上广泛使用的单元测试框架，通过配置 JUnit 集成可以在流水线执行过程中自动执行单元测试，并生成 JUnit 格式的测试报告。

下面是一个简单的流水线配置示例，其中包括了 JUnit 集成，使用了 junit 步骤来执行单元测试并生成测试报告。

1. pipeline {

2.     agent any

3.     stages {

4.         stage('Build') {

5.             steps {

6.                 sh 'make build'

7.             }

8.         }

9.         stage('Test') {

10.             steps {

11.                 sh 'make test'

12.             }

13.             post {

14.                 always {

15.                     junit 'target/surefire-reports/*.xml'

16.                 }

17.             }

18.         }

19.     }

20. }

2、TestNG 集成

TestNG 是 Java 平台上的另一个流行的测试框架，与 JUnit 类似，通过配置 TestNG 集成可以在流水线执行过程中自动执行测试并生成测试报告。

下面是一个简单的流水线配置示例，其中包括了 TestNG 集成，使用了 testng 步骤来执行测试并生成测试报告。

1. pipeline {

2.     agent any

3.     stages {

4.         stage('Build') {

5.             steps {

6.                 sh 'make build'

7.             }

8.         }

9.         stage('Test') {

10.             steps {

11.                 sh 'make test'

12.             }

13.             post {

14.                 always {

15.                     testng 'target/surefire-reports/*.xml'

16.                 }

17.             }

18.         }

19.     }

20. }

3、Selenium 集成

Selenium 是用于自动化 Web 应用程序测试的工具，通过配置 Selenium 集成可以在流水线执行过程中自动执行 Web UI 测试，并生成测试报告。

下面是一个简单的流水线配置示例，其中包括了 Selenium 集成，使用了 sh 步骤来执行 Selenium 测试脚本。

1. pipeline {

2.     agent any

3.     stages {

4.         stage('Build') {

5.             steps {

6.                 sh 'make build'

7.             }

8.         }

9.         stage('Test') {

10.             steps {

11.                 sh 'make test'

12.             }

13.             post {

14.                 always {

15.                     sh 'python selenium_tests.py'

16.                 }

17.             }

18.         }

19.     }

20. }

七、与部署工具集成

将流水线与部署工具集成可以实现自动化部署和发布，从而实现持续交付和持续部署。

此处将介绍两个常用的部署工具，具体可以参考：

Jenkins Pipeline常用插件整理

1、Docker 集成

Docker 是一个流行的容器化平台，通过配置 Docker 集成可以在流水线执行过程中构建、打包和发布 Docker 镜像。

下面是一个简单的流水线配置示例，其中包括了 Docker 集成，使用了 Docker Pipeline 插件提供的 docker.build 和 docker.push 步骤来构建和发布 Docker 镜像。

1. pipeline {

2.     agent any

3.     stages {

4.         stage('Build') {

5.             steps {

6.                 script {

7.                     docker.build('my-image:latest')

8.                 }

9.             }

10.         }

11.         stage('Push') {

12.             steps {

13.                 script {

14.                     docker.withRegistry('https://docker.example.com', 'docker-credentials') {

15.                         docker.image('my-image:latest').push()

16.                     }

17.                 }

18.             }

19.         }

20.     }

21. }

2、Kubernetes 集成

Kubernetes 是一个开源的容器编排平台，通过配置 Kubernetes 集成可以在流水线执行过程中部署和管理容器化应用。

下面是一个简单的流水线配置示例，其中包括了 Kubernetes 集成，使用了 Kubernetes Pipeline 插件提供的 kubectl 步骤来部署应用到 Kubernetes 集群。

1. pipeline {

2.     agent any

3.     stages {

4.         stage('Deploy') {

5.             steps {

6.                 script {

7.                     kubernetesDeploy(

8.                         kubeconfigId: 'my-kube-config',

9.                         configs: 'kube/*.yml'

10.                     )

11.                 }

12.             }

13.         }

14.     }

15. }

感谢每一个认真阅读我文章的人，礼尚往来总是要有的，虽然不是什么很值钱的东西，如果你用得到的话可以直接拿走：

这些资料，对于【软件测试】的朋友来说应该是最全面最完整的备战仓库，这个仓库也陪伴上万个测试工程师们走过最艰难的路程，希望也能帮助到你!有需要的小伙伴可以点击下方小卡片领取