Jenkins Pipeline常用插件整理

大家好，前段时间和大家分享了在Docker中安装Jenkins，今天给大家分享一下Jenkins Pipeline相关的一些插件，当涉及到 Jenkins Pipeline，插件是使其功能更强大、更灵活的关键。让我们一起来探索一些常用的 Jenkins Pipeline 插件，这些插件提供了丰富的功能和工具，帮助开发团队构建、测试和交付他们的软件项目。这些插件为 Jenkins Pipeline 提供了丰富的功能和工具，帮助开发团队构建灵活、高效的 CI/CD 流水线，提高软件交付的质量和速度。

在Docker中安装Jenkins可以参考：

使用Docker安装Jenkins

一、Pipeline插件

Pipeline 是 Jenkins 中的一个重要概念，它允许您将持续交付过程定义为代码。Pipeline 插件提供了创建、管理和执行 Pipeline 脚本的功能，使您能够更灵活地管理构建过程。它是一种通过代码的方式来定义持续集成和持续交付流程的方法。Pipeline 插件为 Jenkins 提供了一个强大的方式来将整个软件交付过程定义为一个可执行的脚本，从而实现了更灵活、可重用、可维护的持续集成和持续交付流程。

https://www.jenkins.io/zh/doc/book/pipeline/

Pipeline 插件的特点：

可编程性：Pipeline 允许使用 Groovy 语言编写流水线脚本，从而可以实现流水线中的各种逻辑、控制流程等。
可视化：Pipeline 插件提供了 Blue Ocean 界面，可以直观地查看和管理流水线的执行状态、构建历史等信息。
可扩展性：Pipeline 允许通过插件来扩展其功能，可以集成各种工具和服务，如 Git、Docker、SonarQube 等。
可重用性：Pipeline 允许将流水线定义为库，并在多个项目中共享和重用，从而提高了流水线的可维护性和可重用性。

如何使用 Pipeline 插件：

创建 Pipeline 项目：在 Jenkins 中创建一个新的 Pipeline 项目。选择"新建任务"，然后选择"Pipeline"类型的项目。
编写 Pipeline 脚本：在 Pipeline 项目配置页面中，找到 Pipeline 脚本编辑框。您可以在此处编写 Groovy 脚本来定义您的流水线。
定义流水线阶段：使用 stage 关键字来定义流水线的各个阶段。每个阶段代表流水线中的一个步骤或任务，如构建、测试、部署等。
配置流水线步骤：在每个阶段中，使用各种流水线步骤来实现具体的操作。例如，使用 git 步骤来拉取代码，使用 sh 步骤来执行 Shell 命令，使用 docker.build 步骤来构建 Docker 镜像等。
保存并触发构建：完成 Pipeline 脚本编写后，点击保存按钮保存配置。然后可以手动触发构建，或者配置触发器来自动触发构建。

示例 Pipeline 脚本：

pipeline {
    agent any
    stages {
        stage('Checkout') {
            steps {
                git 'https://github.com/example/repo.git'
            }
        }
        stage('Build') {
            steps {
                sh 'mvn clean package'
            }
        }
        stage('Test') {
            steps {
                sh 'mvn test'
            }
        }
        stage('Deploy') {
            steps {
                sh 'kubectl apply -f deployment.yaml'
            }
        }
    }
}

这是一个简单的 Pipeline 脚本示例，它包括了拉取代码、构建、测试和部署等阶段。可以根据实际需求编写更复杂的流水线脚本，实现更多功能和流程控制。

二、Docker插件

Docker 插件是 Jenkins 中一个非常实用的插件，它允许在 Jenkins 中集成 Docker 容器平台，以便在构建过程中使用 Docker 容器来隔离环境、执行任务，并加速构建。

https://plugins.jenkins.io/docker-plugin/

Docker 插件的功能：

Docker Agent支持：Docker 插件允许 Jenkins 使用 Docker 容器作为构建代理（Agent），从而实现构建任务的隔离和环境复制。这样可以避免构建任务对 Jenkins 主机环境的影响，并提高构建的一致性和可移植性。
Docker Build和Publish支持：Docker 插件提供了构建 Docker 镜像和发布到 Docker 仓库的支持。可以在 Jenkins 中使用 Dockerfile 构建镜像，并将镜像推送到 Docker 仓库，以便在部署过程中使用。
Docker Pipeline Steps：Docker 插件提供了一组 Pipeline 步骤，用于在 Pipeline 脚本中执行 Docker 相关操作，如构建镜像、运行容器、执行 Docker 命令等。
Docker Registry认证支持：Docker 插件允许配置 Docker 仓库的认证信息，包括用户名密码、凭据等，以便在构建过程中访问私有的 Docker 仓库。

如何使用 Docker 插件：

安装 Docker 插件：首先确保 Jenkins 实例已经安装了 Docker 插件。可以在 Jenkins 的插件管理页面搜索并安装 Docker 插件。
配置全局工具：在 Jenkins 系统管理中，找到"Global Tool Configuration"选项。在这里可以配置 Docker 工具，包括 Docker 客户端路径、Docker 服务器 URI 等。
创建 Docker Agent：在 Jenkins 中创建一个新的构建节点，并选择"Docker"作为启动类型。配置 Docker 容器的镜像、工作目录、环境变量等。
在 Pipeline 中使用 Docker：在 Pipeline 脚本中使用 Docker 相关步骤来执行 Docker 操作。例如，使用 docker.build 步骤构建镜像，使用 docker.image 步骤运行容器等。

示例 Pipeline 脚本中的 Docker 使用：

pipeline {
    agent {
        docker {
            image 'maven:3.8.1-jdk-11'
        }
    }
    stages {
        stage('Build') {
            steps {
                sh 'mvn clean package'
            }
        }
        stage('Test') {
            steps {
                sh 'mvn test'
            }
        }
        stage('Publish') {
            steps {
                docker.build('my-app:latest')
                docker.image('my-app:latest').push()
            }
        }
    }
}

在这个示例 Pipeline 脚本中，我们使用 Docker 容器作为构建代理，使用 Maven 镜像来构建和测试 Java 应用程序。然后，我们使用 Docker 步骤构建镜像，并将镜像推送到 Docker 仓库中。

三、Pipeline GitHub插件

Pipeline GitHub 插件是 Jenkins 中用于与 GitHub 代码托管服务集成的插件。它允许在 Jenkins Pipeline 中直接与 GitHub 仓库交互，包括拉取代码、创建 Pull Request、发送状态通知等操作。

https://plugins.jenkins.io/pipeline-github/

Pipeline GitHub 插件的功能：

代码拉取：Pipeline GitHub 插件可以在 Pipeline 中使用 git 步骤来拉取 GitHub 代码库的代码，方便在构建过程中获取最新的代码。
Pull Request 构建：Pipeline GitHub 插件支持在 Pipeline 中构建 GitHub 上的 Pull Request，可以通过 Pull Request 编号或分支名称来触发构建，并对 Pull Request 进行集成测试和代码审查。
状态通知：Pipeline GitHub 插件可以向 GitHub 提交状态 API 发送构建状态通知，包括成功、失败、挂起等状态，可以在 GitHub 上显示构建状态和结果。
代码审查：Pipeline GitHub 插件支持在 Pipeline 中进行代码审查，可以在构建过程中执行代码静态分析、单元测试等操作，并将结果反馈到 GitHub 上的 Pull Request 中。
Webhooks 支持：Pipeline GitHub 插件支持 GitHub Webhooks，可以在代码提交、Pull Request 创建、状态更新等事件发生时触发 Jenkins Pipeline 构建。

如何使用 Pipeline GitHub 插件：

安装 Pipeline GitHub 插件：首先需要在 Jenkins 的插件管理页面搜索并安装 Pipeline GitHub 插件。安装完成后，可以在 Jenkins Pipeline 中使用相关的步骤和函数来与 GitHub 交互。
配置 GitHub 凭据：在 Jenkins 中配置连接到 GitHub 的凭据，以便 Pipeline GitHub 插件可以通过 HTTPS 或 SSH 方式访问 GitHub 代码仓库。

在 Pipeline 中使用 GitHub 步骤：在 Jenkins Pipeline 脚本中使用 Pipeline GitHub 插件提供的步骤来与 GitHub 仓库进行交互。以下是一些常用的 GitHub 步骤示例：

git: 使用 git 步骤拉取 GitHub 代码库中的代码。
checkout: 使用 checkout 步骤拉取 GitHub 代码库中的代码，更适用于多分支 Pipeline。
githubNotify: 使用 githubNotify 步骤向 GitHub 提交状态通知，更新 Pull Request 的构建状态。
reviewable: 使用 reviewable 步骤在 Pipeline 中进行代码审查，将结果反馈到 GitHub 上的 Pull Request 中。

触发 Pipeline 构建：保存 Pipeline 脚本后，在 GitHub 上进行代码提交、Pull Request 创建等操作，可以触发 Jenkins Pipeline 构建，并在 Jenkins 中执行相应的构建任务。

示例 Pipeline 脚本中的 GitHub 步骤使用：

pipeline {
    agent any
    stages {
        stage('Checkout') {
            steps {
                git credentialsId: 'github-credentials', url: 'https://github.com/username/repo.git'
            }
        }
        stage('Build') {
            steps {
                sh 'mvn clean package'
            }
        }
        stage('Test') {
            steps {
                sh 'mvn test'
            }
        }
        stage('Notify GitHub') {
            steps {
                script {
                    githubNotify context: 'Jenkins Pipeline', description: 'Build completed', targetUrl: 'http://jenkins.example.com/job/my-pipeline/1/', status: 'SUCCESS'
                }
            }
        }
    }
}

在这个示例 Pipeline 脚本中，我们使用 git 步骤拉取 GitHub 上的代码库，然后执行构建和测试操作。最后，我们使用 githubNotify 步骤向 GitHub 提交状态通知，更新 Pull Request 的构建状态。

四、Pipeline Utility Steps插件

Pipeline Utility Steps 插件是 Jenkins 中用于提供一组常用的 Pipeline 步骤，用于处理文件、文本、JSON 等操作的插件。它扩展了 Jenkins Pipeline 的功能，使得在 Pipeline 脚本中可以更方便地进行数据处理和转换。

https://plugins.jenkins.io/pipeline-utility-steps/

Pipeline Utility Steps 插件的功能：

文件操作：Pipeline Utility Steps 插件提供了一组用于文件操作的步骤，包括复制文件、移动文件、删除文件、创建目录等，方便在 Pipeline 中管理文件和目录。
文本操作：Pipeline Utility Steps 插件提供了一组用于文本操作的步骤，包括查找文本、替换文本、拆分文本、合并文本等，方便在 Pipeline 中对文本进行处理和转换。
JSON 操作：Pipeline Utility Steps 插件提供了一组用于 JSON 操作的步骤，包括解析 JSON、生成 JSON、修改 JSON 等，方便在 Pipeline 中处理 JSON 数据。
日期操作：Pipeline Utility Steps 插件提供了一组用于日期操作的步骤，包括日期格式化、日期计算、日期解析等，方便在 Pipeline 中处理日期和时间数据。
环境变量操作：Pipeline Utility Steps 插件提供了一组用于环境变量操作的步骤，包括设置环境变量、获取环境变量、清除环境变量等，方便在 Pipeline 中管理环境变量。

如何使用 Pipeline Utility Steps 插件：

安装 Pipeline Utility Steps 插件：首先需要在 Jenkins 的插件管理页面搜索并安装 Pipeline Utility Steps 插件。安装完成后，您可以在 Pipeline 脚本中使用相关的步骤来进行文件、文本、JSON 和日期等操作。

在 Pipeline 中使用步骤：在 Jenkins Pipeline 脚本中使用 Pipeline Utility Steps 插件提供的步骤来处理数据。以下是一些常用步骤的示例用法：

readFile: 使用 readFile 步骤读取文件内容，并将其存储到变量中。
writeFile: 使用 writeFile 步骤将文本内容写入到文件中。
jsonParse: 使用 jsonParse 步骤解析 JSON 数据，并将其转换为 Groovy Map 对象。
jsonSlurper: 使用 jsonSlurper 步骤解析 JSON 数据，并将其转换为 Groovy 对象。
bat: 使用 bat 步骤在 Windows 上执行批处理命令。
sh: 使用 sh 步骤在 Unix/Linux 上执行 Shell 命令。
env: 使用 env 步骤获取当前环境变量的值。

处理结果：根据步骤的执行结果，您可以在 Pipeline 中进行后续的操作，如根据文件内容执行不同的操作、根据 JSON 数据执行不同的流程等。

示例 Pipeline 脚本中 Pipeline Utility Steps 的使用：

pipeline {
    agent any
    stages {
        stage('Read File') {
            steps {
                script {
                    def content = readFile 'file.txt'
                    echo "File content: ${content}"
                }
            }
        }
        stage('Write File') {
            steps {
                script {
                    writeFile file: 'output.txt', text: 'Hello, world!'
                }
            }
        }
        stage('Parse JSON') {
            steps {
                script {
                    def json = '{"name": "John", "age": 30}'
                    def data = jsonParse(json)
                    echo "Name: ${data.name}, Age: ${data.age}"
                }
            }
        }
    }
}

在这个示例 Pipeline 脚本中，我们使用了 readFile 步骤读取文件内容，使用 writeFile 步骤将文本写入文件，使用 jsonParse 步骤解析 JSON 数据，并在 Pipeline 中输出结果。

五、Pipeline Maven Integration插件

Pipeline Maven Integration 插件是 Jenkins 中用于与 Maven 构建工具集成的插件。它提供了一组 Pipeline 步骤，用于在 Pipeline 中执行 Maven 构建任务，并管理 Maven 项目的依赖关系、版本控制等。

https://plugins.jenkins.io/pipeline-maven/

Pipeline Maven Integration 插件的功能：

Maven 构建任务：Pipeline Maven Integration 插件提供了一组用于执行 Maven 构建任务的 Pipeline 步骤，包括 maven、mvn 等，可以在 Pipeline 中方便地执行 Maven 构建命令。
Maven 依赖管理：Pipeline Maven Integration 插件支持管理 Maven 项目的依赖关系，可以在 Pipeline 中使用 withMaven 步骤来自动下载和缓存依赖，并将其添加到构建路径中。
Maven 镜像配置：Pipeline Maven Integration 插件支持配置 Maven 镜像，可以在 Jenkins 全局配置中设置 Maven 镜像的 URL、凭据等信息，以加速 Maven 构建任务的执行。
Maven 环境变量：Pipeline Maven Integration 插件提供了一些 Maven 相关的环境变量，可以在 Pipeline 中使用这些变量来获取 Maven 的版本、路径等信息。

如何使用 Pipeline Maven Integration 插件：

安装 Pipeline Maven Integration 插件：首先需要在 Jenkins 的插件管理页面搜索并安装 Pipeline Maven Integration 插件。安装完成后，您可以在 Pipeline 脚本中使用相关的步骤来执行 Maven 构建任务。
配置 Maven 环境：在 Jenkins 全局配置中，找到 Maven 配置部分，配置 Maven 的安装路径、全局设置等信息，以确保 Pipeline 可以正确地使用 Maven。

在 Pipeline 中使用 Maven 步骤：在 Jenkins Pipeline 脚本中使用 Pipeline Maven Integration 插件提供的步骤来执行 Maven 构建任务。以下是一些常用的 Maven 步骤的示例用法：

withMaven: 使用 withMaven 步骤包裹 Maven 构建任务，自动下载和缓存依赖，并将其添加到构建路径中。
maven: 使用 maven 步骤执行 Maven 构建命令，如编译、测试、打包等。
mvn: 使用 mvn 步骤执行 Maven 命令，可以传递参数和选项，如 -B（禁用交互模式）等。

处理 Maven 构建结果：根据 Maven 构建任务的执行结果，您可以在 Pipeline 中进行后续的操作，如根据构建状态执行不同的流程、发送构建通知等。

示例 Pipeline 脚本中 Pipeline Maven Integration 的使用：

pipeline {
    agent any
    stages {
        stage('Build') {
            steps {
                script {
                    withMaven(maven: 'M3', mavenSettingsConfig: 'my-maven-settings') {
                        sh 'mvn clean package'
                    }
                }
            }
        }
    }
}

在这个示例 Pipeline 脚本中，我们使用了 withMaven 步骤来执行 Maven 构建任务，其中指定了 Maven 的版本为 'M3'，并使用了名为 'my-maven-settings' 的 Maven 设置配置。在 withMaven 块中，我们执行了 mvn clean package 命令来清理项目并打包构建产物。

六、Pipeline Shared Groovy Libraries插件

Pipeline Shared Groovy Libraries 插件是 Jenkins 中用于管理和共享 Pipeline 脚本库的插件。它允许用户将通用的 Pipeline 脚本封装成库，并在多个 Pipeline 中重用和共享这些脚本，从而提高 Pipeline 的可维护性和可重用性。

https://plugins.jenkins.io/pipeline-groovy-lib/

Pipeline Shared Groovy Libraries 插件的功能：

库定义：Pipeline Shared Groovy Libraries 插件允许用户定义一个或多个 Groovy 脚本库，每个库可以包含一个或多个 Groovy 脚本文件，用于定义 Pipeline 中可重用的函数、类等内容。
库导入：Pipeline Shared Groovy Libraries 插件提供了在 Pipeline 中导入 Groovy 脚本库的功能，可以通过 @Library 注解或 library 步骤来导入库，并在 Pipeline 中调用库中的函数和类。
版本控制：Pipeline Shared Groovy Libraries 插件支持将库存储在版本控制系统（如 Git、Subversion 等）中，以便跟踪和管理库的版本，确保在不同的 Pipeline 中使用相同的库版本。
自动加载：Pipeline Shared Groovy Libraries 插件支持自动加载库的最新版本，当 Pipeline 第一次调用库时，插件会自动从版本控制系统中下载和加载库的最新版本。

如何使用 Pipeline Shared Groovy Libraries 插件：

安装 Pipeline Shared Groovy Libraries 插件：首先需要在 Jenkins 的插件管理页面搜索并安装 Pipeline Shared Groovy Libraries 插件。安装完成后，您可以在 Jenkins 中配置和管理 Groovy 脚本库。
定义 Groovy 脚本库：在版本控制系统中创建一个 Groovy 脚本库，并将通用的 Pipeline 脚本封装成函数、类等形式，并进行适当的组织和命名。
配置 Jenkins 中的库：在 Jenkins 的全局配置中，找到 Pipeline Shared Groovy Libraries 配置部分，添加一个新的库定义，指定库的名称、版本控制信息、路径等。

在 Pipeline 中导入库：在 Jenkins Pipeline 脚本中使用 @Library 注解或 library 步骤来导入 Groovy 脚本库。以下是两种导入库的方式示例：

// 使用 @Library 注解导入库
@Library('my-shared-library') _

pipeline {
    // Pipeline 定义
}




// 使用 library 步骤导入库
pipeline {
    agent any
    stages {
        stage('Example') {
            steps {
                library 'my-shared-library'
                // 调用库中的函数或类
            }
        }
    }
}

调用库中的函数或类：在 Pipeline 中通过导入库的方式，调用库中定义的函数或类，实现对库的重用和共享。

示例 Pipeline 脚本中 Pipeline Shared Groovy Libraries 的使用：

假设我们有一个名为 my-shared-library 的 Groovy 脚本库，其中包含了一个名为 utils.groovy 的文件，定义了一个名为 helloWorld 的函数：

// my-shared-library/utils.groovy
def call() {
    echo 'Hello, world!'
}

我们可以在 Jenkins Pipeline 中导入并调用这个库：

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

pipeline {
    agent any
    stages {
        stage('Example') {
            steps {
                helloWorld()
            }
        }
    }
}

在这个示例 Pipeline 脚本中，我们使用 @Library 注解导入了 my-shared-library 库，并在 Pipeline 中调用了 helloWorld 函数，实现了对库的重用和共享。

七、Pipeline NPM Integration插件

Pipeline NPM Integration 插件是 Jenkins 中用于与 Node.js 和 NPM（Node Package Manager）集成的插件。它提供了一组 Pipeline 步骤，用于在 Pipeline 中执行 Node.js 和 NPM 相关的操作，如安装依赖、运行测试、构建项目等。

https://plugins.jenkins.io/pipeline-npm/

Pipeline NPM Integration 插件的功能：

NPM 命令执行：Pipeline NPM Integration 插件提供了一组用于执行 NPM 命令的 Pipeline 步骤，包括 npmInstall、npmRun、npmTest 等，方便在 Pipeline 中执行 NPM 相关的操作。
NPM 配置：Pipeline NPM Integration 插件支持配置 NPM 的安装路径、全局设置等信息，以确保 Pipeline 可以正确地使用 NPM。
依赖管理：Pipeline NPM Integration 插件支持管理 Node.js 项目的依赖关系，可以在 Pipeline 中使用 npmInstall 步骤自动安装项目的依赖。

如何使用 Pipeline NPM Integration 插件：

安装 Pipeline NPM Integration 插件：首先需要在 Jenkins 的插件管理页面搜索并安装 Pipeline NPM Integration 插件。安装完成后，您可以在 Jenkins Pipeline 中使用相关的步骤来执行 Node.js 和 NPM 相关的操作。
配置 NPM 环境：在 Jenkins 全局配置中，找到 NPM 配置部分，配置 NPM 的安装路径、全局设置等信息，以确保 Pipeline 可以正确地使用 NPM。

在 Pipeline 中使用 NPM 步骤：在 Jenkins Pipeline 脚本中使用 Pipeline NPM Integration 插件提供的步骤来执行 Node.js 和 NPM 相关的操作。以下是一些常用的 NPM 步骤的示例用法：

// npmInstall: 使用 npmInstall 步骤安装项目的依赖。
pipeline {
    agent any
    stages {
        stage('Install Dependencies') {
            steps {
                npmInstall()
            }
        }
    }
}



// npmRun: 使用 npmRun 步骤运行项目中的 NPM 脚本。
pipeline {
    agent any
    stages {
        stage('Run Tests') {
            steps {
                npmRun(script: 'test')
            }
        }
    }
}



// npmTest: 使用 npmTest 步骤运行项目中的测试。
pipeline {
    agent any
    stages {
        stage('Run Tests') {
            steps {
                npmTest()
            }
        }
    }
}

处理 NPM 操作结果：根据 NPM 操作的执行结果，您可以在 Pipeline 中进行后续的操作，如根据测试结果执行不同的流程、发送构建通知等。

示例 Pipeline 脚本中 Pipeline NPM Integration 的使用：

假设我们有一个 Node.js 项目，其中包含一个 package.json 文件，并定义了一个名为 test 的 NPM 脚本，用于运行测试。我们可以在 Jenkins Pipeline 中执行这个测试脚本：

pipeline {
    agent any
    stages {
        stage('Install Dependencies') {
            steps {
                npmInstall()
            }
        }
        stage('Run Tests') {
            steps {
                npmRun(script: 'test')
            }
        }
    }
}

在这个示例 Pipeline 脚本中，我们使用了 npmInstall 步骤来安装项目的依赖，然后使用了 npmRun 步骤来运行项目中的 test 脚本，从而执行项目的测试。