什么是詹金斯?如何以及为什么要使用它?

weixin_0010034

30人浏览 · 2022-08-06 10:40:05

weixin_0010034 · 2022-08-06 10:40:05 发布

持续集成和持续交付是 DevOps 的组成部分,因为它们用于集成方法的多个阶段。市场上有很多 CI/CD 工具,但 Jenkins 除外;基于 Java 的开源 CI/CD 工具在人气榜上名列前茅。我们进行的一项小型调查进一步提升了 Jenkins 的受欢迎程度,导致偶尔有人询问“什么是 Jenkins?”

[ jenkins 管道 ](https://res.cloudinary.com/practicaldev/image/fetch/s--PlBE9Thv--/c_limit%2Cf_auto%2Cfl_progressive%2Cq_auto%2Cw_880/https://www.lambdatest. com/blog/wp-content/uploads/2020/09/Jenkins-poll.png)

在这篇博客中,当我们试图回答“什么是 Jenkins”时,我们还深入探讨了 Jenkins 管道是什么,Jenkins 是如何工作的,等等。我们还将使用 Jenkins Maven 项目和 Jenkins 管道演示 Jenkins 的持续测试。完成本篇博客后,您不仅会了解 Jenkins 是什么,还将获得足够的信心使用 Jenkins 在 DevOps](https://www.lambdatest.com/blog/how-to-implement-continuous-testing-in-devops-like-a-pro/?utm_source=dev&utm_medium=Blog&utm_campaign=HS-8092020&utm_term=HS)中进行[连续测试。

什么是詹金斯?

[](https://res.cloudinary.com/practicaldev/image/fetch/s--AAWLBeSS--/c_limit%2Cf_auto%2Cfl_progressive%2Cq_auto%2Cw_880/https://www.lambdatest. com/blog/wp-content/uploads/2020/09/Jenkins-Logo.png)

Jenkins 是一个完全用 Java 编写的开源服务器。它允许您执行一系列操作来实现持续集成过程,这也是以自动化的方式。

此 CI 服务器在 Apache Tomcat 等 servlet 容器中运行。 Jenkins 通过自动化与构建、测试和部署相关的部分来促进软件项目中的持续集成和持续交付。这使开发人员可以轻松地通过将更改集成到项目中来不断改进产品。

Jenkins 以持续的方式自动化软件构建,并让开发人员及早了解错误。强大的 Jenkins 社区是其受欢迎的主要原因之一。 Jenkins 不仅是可扩展的,而且还有一个蓬勃发展的插件生态系统。

可以使用 Jenkins 执行的一些可能步骤是:

使用 Gradle、Maven 等构建系统构建软件。
使用 Nose2、PyTest、Robot、Selenium 等测试框架进行自动化测试。
执行测试脚本(使用 Windows 终端、Linux shell 等)
获取测试结果并执行发布操作,例如打印测试报告等。
针对不同的输入组合执行测试场景以获得改进的测试覆盖率。
自动创建和测试工件的持续集成 (CI)。这有助于在开发的早期阶段识别产品中的问题。

在什么是 Jenkins 博客的时候,它有近 1500 多个由社区贡献的插件。插件有助于定制使用 Jenkins 的体验,同时为加速与构建、部署和自动化项目相关的活动提供支持。

詹金斯的历史

Jenkins 自 2011 年以来一直处于开发阶段,因此具有先发优势。Kohsuke Kawaguchi 在 Sun Microsystems 工作时创建了 Jenkins(当时称为“Hudson”)。 Hudson 创建于 2004 年夏天,第一个版本是在 2005 年 2 月。

在 Oracle 收购 Sun Microsystems 后,一项提议得到了 Hudson 社区的批准,以创建 Jenkins 项目。 2011 年 2 月,甲骨文打算继续开发 Hudson,因此 Hudson 被分叉而不是重命名为 Jenkins。

尽管 Hudson 和 Jenkins 是独立开发的,但 Jenkins 获得的项目和贡献者比 Hudson 多得多。因此,Hudson 不再由社区维护。

Jenkins 发布周期

与其他开源项目一样,Jenkins 也生产两条发布线——LTS(长期支持)和每周(定期)发布。 Jenkins 非常擅长发布,因为稳定版本每四个星期发布一次。

在这篇‘, what is Jenkins’ 文章的时候,Jenkins LTS 的最新版本是 2.235.2,Jenkins Weekly 是 2.249。

詹金斯的显着特点

Jenkins 更多的是功能驱动而不是 UI 驱动,因此,了解 Jenkins 是一个学习曲线。以下是 Jenkins 提供的以开发人员为中心的强大功能:

1\。易于安装和配置

Jenkins 是一个独立的 Java 程序,它与安装它的平台无关。它适用于几乎所有流行的操作系统,例如 Windows、不同风格的 Unix 和 Mac OS。

它可作为普通安装程序以及 .war 文件使用。安装后,可以使用其 Web 界面轻松进行配置。

2\。开源

由于它是开源的,因此可以免费使用。社区的大力参与使其成为强大的 CI/CD 工具。您可以从 Jenkins 社区获得支持,无论是可扩展性、支持、文档还是与 Jenkins 相关的任何其他功能。

3\。蓬勃发展的插件生态系统

Jenkins 的支柱是社区,社区成员在更新中心提供的近 1500 多个插件的开发(和测试)中发挥了重要作用。

4\。易于分发

Jenkins 的设计方式使得跨多台机器和平台分配工作相对容易,以加速构建、测试和部署。

詹金斯是如何工作的?

在什么是 Jenkins 博客的这一部分中,我们将了解 Jenkins 的内部功能,即一旦开发人员提交对存储库的更改会发生什么,以及如何在 Jenkins 中实现 CI/CD。我们还研究了 Jenkins 中的主从架构。

詹金斯的架构

在深入了解 Jenkins 是如何工作的之前,我们必须了解 Jenkins 的架构。这些是概述 Jenkins 中不同元素之间交互的一系列步骤:

开发人员对源代码进行必要的修改并将更改提交到存储库。该文件的新版本将在用于维护源代码存储库的版本控制系统中创建。
Jenkins CI 服务器不断检查存储库是否有任何更改(以代码或库的形式),并且更改由服务器拉取。
在下一步中,我们确保带有“拉取更改”的构建是否通过。构建服务器使用代码执行构建,如果构建过程成功,则会生成一个可执行文件。如果构建失败,则会向开发人员发送一封带有构建日志和其他构建工件链接的自动电子邮件。
在成功构建的情况下,构建的应用程序(或可执行文件)被部署到测试服务器。此步骤有助于实现连续测试,其中新构建的可执行文件通过一系列自动化测试。如果更改导致功能中断,开发人员会收到警报。
如果签入的代码没有构建、集成和测试问题,则更改和测试的应用程序会自动部署到生产/生产服务器。

这是 Jenkins 架构的图解表示:

[ Jenkins 架构 ](https://res.cloudinary.com/practicaldev/image/fetch/s--qTINsR1x--/c_limit%2Cf_auto%2Cfl_progressive%2Cq_auto%2Cw_880/https://www.lambdatest. com/blog/wp-content/uploads/2020/09/Jenkins-architecture-1.png)

单个 Jenkins 服务器可能不足以实现以下要求:

测试需要在不同的环境中执行(即使用不同语言编写的代码,例如 Java、Python、C 等提交给版本控制系统),其中单个服务器可能无法满足要求。
单个 Jenkins 服务器可能不足以处理大型软件项目带来的负载。

在这种情况下,Jenkins 的分布式(或主从)架构用于持续集成和测试。深入了解 Jenkins 的工作原理,我们来看看 Jenkins 的架构。

Jenkins 中的主从架构

Jenkins 中的主从(或分布式)架构用于管理分布式构建。主机和从机通过 TCP/IP 协议进行通信。

这些是 Jenkins Master 和 Slave(s) 的角色和职责:

詹金斯大师

Jenkins 中的主服务器是 Master。以下是 Jenkins Master 处理的工作:

计划构建作业
在主从生态系统中选择合适的从节点来调度构建。
监控从站并在需要时使它们联机/脱机。
向开发人员展示构建结果(和报告)。

Jenkins master 也可以直接执行作业,但始终建议为构建和执行相关任务选择适当的 slave(s)。

詹金斯奴隶

从站是连接到主站的远程机器。根据项目和构建要求,您可以选择“N”个从站。从站可以在不同的操作系统上运行,并且根据“构建请求的类型”,主站选择适当的从站进行构建执行和测试。

以下是 Jenkins Slave 处理的工作:

听取 Jenkins Master 的命令。
执行由 Master 分派的构建作业。
开发人员可以灵活地在特定的 Slave 或特定类型的 Slave 上运行构建和执行测试。默认选项是 Jenkins Master 为工作选择最适合的 Slave。

这是 Jenkins 工作原理的简单图解,多个 Jenkins Slave 连接到 Jenkins Master:

[ 詹金斯奴隶 ](https://res.cloudinary.com/practicaldev/image/fetch/s--wrAZ_ITZ--/c_limit%2Cf_auto%2Cfl_progressive%2Cq_auto%2Cw_880/https://www.lambdatest. com/blog/wp-content/uploads/2020/09/image-2.png)

Jenkins在主从架构中是如何工作的?

在什么是 Jenkins 博客的上一部分中,我们谈到了 Jenkins 中 Master 和 Slave(s) 的简要职责。让我们看看 Jenkins 在主从(或分布式)架构中是如何工作的:

在下图所示的 Jenkins Master-Slave 架构中,有三个 Slave,每个 Slave 运行在不同的操作系统(即 Windows 10、Linux 和 Mac OS)上。

[ 主从架构 ](https://res.cloudinary.com/practicaldev/image/fetch/s--GpMjE85G--/c_limit%2Cf_auto%2Cfl_progressive%2Cq_auto%2Cw_880/https://www. lambdatest.com/blog/wp-content/uploads/2020/09/remote-source.png)

开发人员在左侧描述的“远程源代码存储库”中签入他们各自的代码更改。
只有 Jenkins 主服务器连接到存储库,它会定期检查代码更改(在存储库中)。所有的 Jenkins Slave 都连接到 Jenkins Master。
Jenkins master 根据执行构建所需的环境将请求(用于构建和测试)分派给适当的 Jenkins Slave。这使您可以在整个架构的不同环境中执行构建和执行测试。
Slave 执行测试,生成测试报告,发送给 Jenkins Master 进行监控。

随着开发人员不断推送代码,Jenkins Slaves 可以为不同平台运行代码的不同构建版本。 Jenkins Master(或 Master Node)控制各自的构建应该如何运行。

在 What is Jenkins 博客的后续部分中,我们将介绍设置 Jenkins Master 和 Slaves 的步骤。

如何安装詹金斯?

在什么是 Jenkins 博客的这一部分中,我们将向您展示如何在 Windows 10 上安装 Jenkins。Jenkins 可以下载用于其他操作系统,例如不同风格的 Unix(例如 UBuntu、Gentoo、FreeBSD 等),以及苹果系统。您也可以将 Jenkins 放入 Docker 容器中。请访问以下载所需的 Jenkins 安装程序。

Jenkins 安装程序也可用作通用 Java 包 (.war)。如果您使用 Jenkins 和 Selenium 执行跨浏览器测试,我们建议使用 .war 文件,因为您可以通过在非无头模式下在浏览器上执行的自动化测试来见证测试场景的执行。

Jenkins 安装的先决条件

如果机器上没有 JDK(Java SE 开发工具包),请根据您的系统配置(即 32 位或 64 位)下载 JDK 8。在撰写本文时,适用于 Windows 的 JDK 的最新版本是 jdk-8u261-windows*。

2、在系统环境变量中添加JDK安装路径。 JRE(Java 运行时环境)也需要这样做。

添加指向JDK 8 安装位置的环境变量JAVA_HOME。

[ jenkins 教程 ](https://res.cloudinary.com/practicaldev/image/fetch/s--PhAPCJUz--/c_limit%2Cf_auto%2Cfl_progressive%2Cq_auto%2Cw_880/https://www.lambdatest. com/blog/wp-content/uploads/2020/09/jenkins-tutorial.png)

在 Windows 10 上安装 Jenkins(使用 Jenkins 安装程序)的步骤

下载稳定版Jenkins for Windows
解压下载的文件并开始安装过程。只需按照安装程序屏幕上提到的步骤操作,直到安装完成。系统可能会提示您输入用户名和密码,您只需使用系统中的管理员帐户登录,然后按照这些步骤即可。

[ jenkins 安装 ](https://res.cloudinary.com/practicaldev/image/fetch/s--zJNkUbqo--/c_limit%2Cf_auto%2Cfl_progressive%2Cq_auto%2Cw_880/https://www.lambdatest. com/blog/wp-content/uploads/2020/09/jenkins-installation.png)

默认情况下,Jenkins 监听 8080 端口。安装完成后,您需要输入< installation-directory >\Jenkins\secrets\ initialAdminPassword中存在的 initialAdminPassword

[ Jenkins 听 ](https://res.cloudinary.com/practicaldev/image/fetch/s--_3Mh3kyE--/c_limit%2Cf_auto%2Cfl_progressive%2Cq_auto%2Cw_880/https://www.lambdatest. com/blog/wp-content/uploads/2020/09/Jenkins-listens.png)

系统将提示您创建管理员用户。这些凭据可用于登录 Jenkins(而不是使用 initialAdminPassword)。

[ 登录 Jenkins ](https://res.cloudinary.com/practicaldev/image/fetch/s--Bjx-gF_H--/c_limit%2Cf_auto%2Cfl_progressive%2Cq_auto%2Cw_880/https://www .lambdatest.com/blog/wp-content/uploads/2020/09/logging-into-Jenkins.png)

Jenkins 已准备好使用。

[ jenkins 教程 ](https://res.cloudinary.com/practicaldev/image/fetch/s--8IK-C49R--/c_limit%2Cf_auto%2Cfl_progressive%2Cq_auto%2Cw_880/https://www. lambdatest.com/blog/wp-content/uploads/2020/09/Jenkins-is-ready.png)

可选步骤(更改与 Jenkins 服务关联的端口)

如果某些其他服务(在安装 Jenkins 的机器上)使用端口 8080,Jenkins 可能会在启动时遇到问题。您可以使用 net stop 命令停止服务(在端口 8080 上)或更改与 Jenkins 关联的端口号。

更改端口号是更好的选择,因为端口 8080 上的服务仍然可以与 Jenkins 一起运行。要更改 Jenkins 使用的端口,请转到< Jenkins-installation-folder >\Jenkins\jenkins.xml

在文件中搜索 httpPort 并将 8080 更改为首选端口(例如,在我们的示例中为 9090)。正如我们在上面的步骤 2 中提到的,您需要具有管理员权限才能执行此更改。

<service>
  <id>Jenkins</id>
  <name>Jenkins</name>
  <description>This service runs Jenkins automation server.</description>
  <env name="JENKINS_HOME" value="%BASE%"/>
  <!--
    if you'd like to run Jenkins with a specific version of Java, specify a full path to java.exe.
    The following value assumes that you have java in your PATH.
  -->
  <executable>%BASE%\jre\bin\java</executable>
  <arguments>-Xrs -Xmx256m -Dhudson.lifecycle=hudson.lifecycle.WindowsServiceLifecycle -jar "%BASE%\jenkins.war" --httpPort=9090 --webroot="%BASE%\war"</arguments>

更改完成后,重新启动 Jenkins 服务并在 Web 浏览器中打开 localhost:port-number(例如localhost:9090)。使用用户名和密码(在步骤 4 中创建)登录。

[ jenkins 是什么](https://res.cloudinary.com/practicaldev/image/fetch/s--GGCDH3_p--/c_limit%2Cf_auto%2Cfl_progressive%2Cq_auto%2Cw_880/https://www.lambdatest .com/blog/wp-content/uploads/2020/09/image7.png)

在 Windows 10 上安装 Jenkins(使用 .war)的步骤

1.下载.war格式的Jenkins安装程序

Jenkins 可以直接从命令行(或终端)通过执行以下命令启动:

java -Dhudson.model.DirectoryBrowserSupport.CSP="sandbox allow-scripts allow-popups allow-popups-to-escape-sandbox; style-src 'unsafe-inline' *;" -Dsvnkit.http.sslProtocols=TLSv1 -jar Jenkins.war --httpPort=9090

默认情况下,Jenkins 使用端口 8080,但在上面显示的命令中,我们在端口 9090 启动 Jenkins。您可以使用不用于任何其他服务的端口号。

[ Jenkins 使用端口 8080 ](https://res.cloudinary.com/practicaldev/image/fetch/s--Qs6qMjoN--/c_limit%2Cf_auto%2Cfl_progressive%2Cq_auto%2Cw_880/https://www. lambdatest.com/blog/wp-content/uploads/2020/09/Jenkins-uses-port-8080.png)

Jenkins 服务启动后,在浏览器中访问localhost:9090即可开始使用 Jenkins。

[ Jenkins 服务 ](https://res.cloudinary.com/practicaldev/image/fetch/s--zDiewKTV--/c_limit%2Cf_auto%2Cfl_progressive%2Cq_auto%2Cw_880/https://www.lambdatest. com/blog/wp-content/uploads/2020/09/Jenkins-service.png)

在这篇“什么是 Jenkins”的博客中,我们将使用 .war 格式的 Jenkins,因为只有使用这种格式的 Jenkins,才能在非无头模式下执行跨浏览器测试。

如何配置Jenkins?

在“什么是 Jenkins”博客的这一部分中,我们将了解如何在 Jenkins 中进行用户管理,为用户分配角色,以及在 Jenkins 中设置 Master 和 Slaves。

Jenkins 中的用户管理

要在 Jenkins 中管理用户,您应该导航到管理 Jenkins 🡪 配置全局安全性。理想的选择是让 Jenkins 拥有自己的用户数据库。您可以创建一个只有读取权限的用户 Anonymous。为您打算在下一步中添加的用户创建条目。

在授权策略中,选择“基于矩阵的安全性”。

[ jenkins 是什么](https://res.cloudinary.com/practicaldev/image/fetch/s--MaPHdRO6--/c_limit%2Cf_auto%2Cfl_progressive%2Cq_auto%2Cw_880/https://www.lambdatest .com/blog/wp-content/uploads/2020/09/image23.png)

单击“添加用户或组”按钮并在下一个框中输入预期的用户/组名称。

[ jenkins 是什么](https://res.cloudinary.com/practicaldev/image/fetch/s--bL0yM4Iq--/c_limit%2Cf_auto%2Cfl_progressive%2Cq_auto%2Cw_880/https://www.lambdatest .com/blog/wp-content/uploads/2020/09/Add-user-or-group.png)

在登录页面上,您应该为刚刚获得访问权限的新创建的用户(例如我们的例子中的 Himanshu Sheth)创建一个帐户。

在 Jenkins 中为用户分配角色

要创建基于角色的授权策略,需要安装基于角色的授权策略插件。安装插件-

转到管理 Jenkins 🡪 管理插件 🡪 在可用选项卡下输入“基于角色的授权策略”。单击“安装”以安装插件。
在分配角色之前,将授权策略更改为基于角色的策略而不是基于矩阵的安全性很重要。

[ jenkins 是什么](https://res.cloudinary.com/practicaldev/image/fetch/s--tk1Z4-tn--/c_limit%2Cf_auto%2Cfl_progressive%2Cq_auto%2Cw_880/https://www .lambdatest.com/blog/wp-content/uploads/2020/09/image9-1.png)

在“Manage Jenkins”中,您会看到“Manage and Assign Roles”,如下所示。

[ 管理 Jenkins ](https://res.cloudinary.com/practicaldev/image/fetch/s--AKKsCchP--/c_limit%2Cf_auto%2Cfl_progressive%2Cq_auto%2Cw_880/https://www.lambdatest. com/blog/wp-content/uploads/2020/09/Manage-Jenkins.png)

创建一个新的全局角色,例如开发人员并选择您要分配给该角色的权限。

[ 创建一个新的全局角色 ](https://res.cloudinary.com/practicaldev/image/fetch/s--m9wVU7nR--/c_limit%2Cf_auto%2Cfl_progressive%2Cq_auto%2Cw_880/https://www .lambdatest.com/blog/wp-content/uploads/2020/09/Create-a-new-global-role.png)

您现在可以分配项目角色、项目角色或节点角色。在我们的例子中,角色“开发者”应该能够访问以 L 开头的构建作业。Pattern 是作业名称的正则表达式值,它应该是 [L]?.* 这是项目角色的示例对于名为“开发人员”的角色。

[ jenkins 是什么](https://res.cloudinary.com/practicaldev/image/fetch/s--Q9_aKfqT--/c_limit%2Cf_auto%2Cfl_progressive%2Cq_auto%2Cw_880/https://www.lambdatest .com/blog/wp-content/uploads/2020/09/image25.png)

如何在 Jenkins 中设置主从?

在前面标题为“Jenkins 中的主从架构”的“什么是 Jenkins”博客部分中,我们了解了 Jenkins 的架构。在这里,我们将演示在 Windows 10 上创建 Jenkins 从站(或节点),以进一步了解 Jenkins 是如何工作的。

创建从属(或代理)的先决条件

在我们继续创建从节点之前,必须在 Jenkins 的“全局安全”设置中更改以下设置:

转到“管理 Jenkins”🡪 配置全局安全并更改以下设置:

[ 设置主从 ](https://res.cloudinary.com/practicaldev/image/fetch/s--J_ej2zPM--/c_limit%2Cf_auto%2Cfl_progressive%2Cq_auto%2Cw_880/https://www. lambdatest.com/blog/wp-content/uploads/2020/09/image27.png)

前往‘Authentication’🡪‘Security Realm’,将设置更改为‘Jenkins’自己的用户数据库’。

[](https://res.cloudinary.com/practicaldev/image/fetch/s--DvYAFo5v--/c_limit%2Cf_auto%2Cfl_progressive%2Cq_auto%2Cw_880/https://www.lambdatest.com /blog/wp-content/uploads/2020/09/Authentication.png)

进入‘授权’🡪策略,更改为‘基于项目的矩阵授权策略’。为用户“匿名用户”启用“读取”和“系统读取”属性。在“代理部分”中为用户“匿名用户”启用“连接”。

[ 基于项目的矩阵授权 ](https://res.cloudinary.com/practicaldev/image/fetch/s--lTd62j_o--/c_limit%2Cf_auto%2Cfl_progressive%2Cq_auto%2Cw_880/https://www .lambdatest.com/blog/wp-content/uploads/2020/09/Project-based-Matrix-Authorization.png)

转到“代理”🡪“入站代理的 TCP 端口”并将设置更改为“随机”。
转到“代理🡪主安全”并启用“启用代理→主访问控制”。将“SSH 服务器”部分中的“SSHD 端口”设置更改为“禁用”。

[ 主安全 ](https://res.cloudinary.com/practicaldev/image/fetch/s--o-Dx9WeD--/c_limit%2Cf_auto%2Cfl_progressive%2Cq_auto%2Cw_880/https://www. lambdatest.com/blog/wp-content/uploads/2020/09/Master-Security.png)

点击 Apply 和 Save 保存这些设置。

在 Jenkins 中创建从站的步骤

完成创建代理(或节点)的先决条件后,我们进入“管理 Jenkins”部分并进入“管理节点和云”。

[ 管理 Jenkins ](https://res.cloudinary.com/practicaldev/image/fetch/s--SvqcdrH4--/c_limit%2Cf_auto%2Cfl_progressive%2Cq_auto%2Cw_880/https://www.lambdatest. com/blog/wp-content/uploads/2020/09/Manage-Jenkins-1.png)

单击新节点并给节点一个适当的名称(例如 Slave)。启用“永久代理”设置,以便代理对 Jenkins 是永久的。

[ 永久代理 ](https://res.cloudinary.com/practicaldev/image/fetch/s--bKMH_NjC--/c_limit%2Cf_auto%2Cfl_progressive%2Cq_auto%2Cw_880/https://www.lambdatest. com/blog/wp-content/uploads/2020/09/Permanent-Agent.png)

1.在这一步,需要输入节点从机的详细信息。 No (#) of executors 是从站可以并行运行的作业数。我们将此设置保持为 2。Labels 是从属的标识符,如果您想在该特定从属上执行作业(通过 Jenkins 管道),这很有用。

远程根目录是存储 agent.jar 的位置,它可以指向您机器中的任何目录。在我们的例子中,我们将 Remote Root Directory 设置为C:\Jenkins_Slave。

[ 远程根目录 ](https://res.cloudinary.com/practicaldev/image/fetch/s--otn_BmLN--/c_limit%2Cf_auto%2Cfl_progressive%2Cq_auto%2Cw_880/https://www.lambdatest .com/blog/wp-content/uploads/2020/09/Permanent-Agent-1.png)

在使用中,您可以选择“尽可能多地使用此节点”。如下图所示,可以通过不同的方式启动从站(或代理),但我们选择“通过连接到主站启动代理”选项。

[ 连接到 Master ](https://res.cloudinary.com/practicaldev/image/fetch/s--jerSbIc2--/c_limit%2Cf_auto%2Cfl_progressive%2Cq_auto%2Cw_880/https://www. lambdatest.com/blog/wp-content/uploads/2020/09/onnecting-to-the-Master.png)

在 Availability 中,您可以保持“尽可能保持此代理在线”,其余设置可以保持默认状态。单击“保存”以创建名为“Slave”的代理。

[ 设置主从 ](https://res.cloudinary.com/practicaldev/image/fetch/s--opzW7Xqg--/c_limit%2Cf_auto%2Cfl_progressive%2Cq_auto%2Cw_880/https://www. lambdatest.com/blog/wp-content/uploads/2020/09/image17-1.png)

创建了名为“Slave”的新节点,但其状态为离线。

[ 状态为离线 ](https://res.cloudinary.com/practicaldev/image/fetch/s--2U0SYTPY--/c_limit%2Cf_auto%2Cfl_progressive%2Cq_auto%2Cw_880/https://www.lambdatest .com/blog/wp-content/uploads/2020/09/status-is-offline.png)

单击名为“Slave”的节点,您将看到代理(即从节点)可以连接到 Jenkins 的不同方式。

单击启动按钮并将 slave-agent.jnlp 保存在指定目录中(即在我们的示例中为C:\Jenkins_Slave)。单击 agent.jar(在“如果代理无头”选项中提到)并将 agent.jar 保存在同一位置。如果您想在无头模式下使用浏览器进行测试,将使用此 jar。

[ slave-agent ](https://res.cloudinary.com/practicaldev/image/fetch/s--5mtFwx50--/c_limit%2Cf_auto%2Cfl_progressive%2Cq_auto%2Cw_880/https://www.lambdatest .com/blog/wp-content/uploads/2020/09/image28.png)

要启动新创建的名为“Slave”的代理,请转到终端并执行以下命令:

javaws http://localhost:9090/computer/Slave/slave-agent.jnlp

这将打开名为“Jenkins Remoting Agent”的应用程序。单击运行以启动应用程序。

[ Jenkins Remoting Agent ](https://res.cloudinary.com/practicaldev/image/fetch/s--ZqUU4jaL--/c_limit%2Cf_auto%2Cfl_progressive%2Cq_auto%2Cw_880/https://www.lambdatest .com/blog/wp-content/uploads/2020/09/image32.png)

如您所见,名为“Slave”的代理的状态为已连接。同样可以通过查看相应节点的状态来验证。

[ 代理名为'Slave ](https://res.cloudinary.com/practicaldev/image/fetch/s--t5DY2bUA--/c_limit%2Cf_auto%2Cfl_progressive%2Cq_auto%2Cw_880/https://www. lambdatest.com/blog/wp-content/uploads/2020/09/Agent-named-%25E2%2580%2598Slave.png)

[](https://res.cloudinary.com/practicaldev/image/fetch/s--zKKjX_UX--/c_limit%2Cf_auto%2Cfl_progressive%2Cq_auto%2Cw_880/https://www.lambdatest.com /blog/wp-content/uploads/2020/09/Slave.png)

或者,如果要在无头模式下使用代理,您可以执行以下命令。

java -jar agent.jar -jnlpUrl http://localhost:9090/computer/Slave/slave-agent.jnlp -workDir "c:\Jenkins_Slave"

这是执行快照:

启动 Slave 节点的第三个选项是通过双击来调用 slave-agent.jnlp。

[](https://res.cloudinary.com/practicaldev/image/fetch/s--kOpMT67a--/c_limit%2Cf_auto%2Cfl_progressive%2Cq_auto%2Cw_880/https://www.lambdatest .com/blog/wp-content/uploads/2020/09/slave-agent.png)

如下图所示,“Slave”节点的状态为在线。

[ Slave'节点 ](https://res.cloudinary.com/practicaldev/image/fetch/s--QNOE6MS2--/c_limit%2Cf_auto%2Cfl_progressive%2Cq_auto%2Cw_880/https://www.lambdatest .com/blog/wp-content/uploads/2020/09/Slave%25E2%2580%2599-node.png)

由于新代理已启动并运行,您现在可以在“从”节点上执行作业。

什么是 Jenkins 流水线?

Jenkins 中的流水线是一组按特定顺序相互关联的作业(或事件)。 Jenkins Pipeline 是一组或一组插件,为持续交付管道的实施和集成到 Jenkins 中提供支持。

Pipeline 还提供了一组工具,可用于通过“管道域特定语言 (DSL)”语法对简单和复杂的交付管道“作为代码”进行建模。

Jenkins 流水线中的每个作业都依赖于一个或多个事件。 Jenkins 中的持续交付管道由四个状态组成——构建、部署、测试和发布。这些状态中的每一个都由按顺序执行的事件组成。

什么是 Jenkinsfile?

现在您了解了什么是 Jenkins 管道,我们可以更深入地研究这个概念。 Jenkins 流水线的整个定义被写入一个名为 Jenkinsfile 的文本文件中。它包含运行 Jenkins 流水线所需的步骤。 “管道即代码”可以使用 Jenkinsfile 来实现,并且使用领域特定语言 (DSL) 来定义它。

Jenkinsfile 也可以提交到项目的源代码控制存储库。使用 Jenkinsfile,CD 流水线也被视为应用程序的一部分,它像任何其他代码一样进行版本控制、提交和审查。

Jenkinsfile 的一些主要好处是:

单个 Jenkinsfile 可用于为所有分支创建管道构建过程并执行拉取请求。
管道中的实现可以像普通源代码一样查看。
管道的审计跟踪。
管道的单一来源可以由与项目关联的多个成员查看和编辑。

尽管可以在 Web UI 或 Jenkinsfile 中定义 Pipeline,但建议在 Jenkinsfile 中定义 Jenkins Pipeline 并在源代码控制存储库中维护相同的内容。

定义 Jenkinsfile 的语法

要定义什么是 Jenkins 管道,可以使用以下类型的语法编写 Jenkinsfile:

a。声明式

声明式流水线是 Jenkins 流水线的最新功能,它使读取和编写流水线代码变得更加容易。与流水线的脚本语法不同,声明式语法有助于以简单的方式控制流水线的不同方面。

b。脚本

Scripted Pipeline 是将 Jenkins Pipeline 编写为代码的一种更传统的方式。它使用传统的基于 Groovy 的语法。 Jenkins 的 Web UI 通常用于在 Jenkinsfile 中编写脚本化管道。

Jenkins Pipeline的重要概念

继续了解什么是 Jenkins 流水线,如果您打算使用 Jenkins 流水线,以下是一些需要充分理解的基本概念:

a。管道

流水线由一组编写为代码的指令组成。它定义了整个构建过程,理想情况下由构建、测试和交付应用程序的不同阶段组成。

b。节点

Node 是一台机器,它是 Jenkins 环境的一部分。 Jenkins 流水线在通常是脚本化流水线语法的一部分的节点块上执行。

c。阶段

Jenkins 流水线中的阶段由一个独特的任务子集组成,例如构建、测试、部署等。许多插件使用阶段块来提供 Jenkins 状态(和进度)的可视化。

d。步

Step 是一个单一的任务,它告诉 Jenkins 究竟需要做什么。例如,设置环境变量可以一步完成,执行构建命令也可以是一步。总的来说,一个 Jenkins Pipeline 由一系列步骤组成。

使用Jenkins Pipeline的优势

Jenkins Pipeline 有助于将一组丰富的自动化工具添加到 Jenkins。因此,Jenkins 可用于简单的持续集成以及全面的 CD 管道。

以下是使用 Jenkins Pipeline 的一些主要原因:

由于 Jenkins Pipeline 是作为代码实现的,因此可以在源代码控制存储库中进行检查。团队可以查看、编辑和迭代交付管道。
Jenkins 流水线很健壮。如果服务器目睹计划外的重新启动,管道会自动恢复。
管道进程可以暂停并等待来自用户的任何输入。
管道用途广泛,因为它们可用于实现复杂的 CD 要求,包括并行执行工作。
Jenkins Pipelines 可由插件开发人员和用户使用 Pipeline Shared Libraries 进行扩展。

声明性管道样本

这是声明式管道的一个简单示例-

pipeline {
    agent any
    stages {
        stage('Build') { 
            steps {
            }
        }
        stage('Test') { 
            steps {
            }
        }
        stage('Deploy') { 
            steps {
            }
        }
    }
}

流水线块定义了通过定义的流水线完成的工作。下面列出了这个管道的一些基本细节:

代理“任何”表示流水线阶段可以在任何可用的代理上执行。

2.“构建”、“测试”和“部署”是管道中的不同阶段。它们中的每一个都将按顺序运行。

“步骤”内的说明指示作为特定“阶段”的一部分需要执行的工作。例如, sh ‘build command’ 可用于在 ‘Build’ 阶段触发构建命令。

我们没有介绍脚本化管道,因为这超出了本博客的范围。在 What is Jenkins 博客的后半部分,我们将演示在 Maven 项目中使用声明式管道。

詹金斯示范

我们希望以上部分有助于回答以下问题——什么是 Jenkins,Jenkins 是如何工作的,以及 Jenkins Pipeline 是什么。在本节中,我们将通过 Maven 项目 和 Pipeline 项目 演示 Jenkins 的使用。

测试场景

1.导航到https://lambdatest.github.io/sample-todo-app/

选择前两个复选框
在 ID 为“sampletodotext”的文本框中输入“Happy Testing at LambdaTest”
选择“添加”按钮,检查文本是否已添加

执行

TestNG 测试框架用于执行Selenium 测试自动化。有关 TestNG 的快速回顾,您可以参考本指南以在 Eclipse 中创建 TestNG 项目。

package org.selenium4;

import org.openqa.selenium.chrome.ChromeDriver;
import org.testng.annotations.AfterClass;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.Test;
import org.openqa.selenium.By;
import org.openqa.selenium.WebElement;
import java.util.Map;
import java.util.*;
import io.github.bonigarcia.wdm.WebDriverManager;

public class CrossBrowserTest {
    protected static ChromeDriver driver;
    String URL = "https://lambdatest.github.io/sample-todo-app/";

    @BeforeClass
    public void testSetUp() {
        WebDriverManager.chromedriver().setup();
        driver = new ChromeDriver();
    }

    @Test
    public void test_Selenium4_ToDoApp() throws InterruptedException {
        driver.navigate().to(URL);
        driver.manage().window().maximize();

        try {
            /* Let's mark done first two items in the list. */
            driver.findElement(By.name("li1")).click();
            driver.findElement(By.name("li2")).click();

            /* Let's add an item in the list. */
            driver.findElement(By.id("sampletodotext")).sendKeys("Happy Testing at LambdaTest");
            driver.findElement(By.id("addbutton")).click();

            /* Let's check that the item we added is added in the list. */
            String enteredText = driver.findElement(By.xpath("/html/body/div/div/div/ul/li[6]/span")).getText();
            if (enteredText.equals("Happy Testing at LambdaTest")) {
                System.out.println("Demonstration of Jenkins is complete");
            }
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
    }

    @AfterClass
    public void tearDown() {
        if (driver != null) {
            driver.quit();
        }
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>org.selenium4.SeleniumGrid4</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <!-- https://mvnrepository.com/artifact/com.github.lambdatest/lambdatest-tunnel-binary -->
        <dependency>
            <groupId>org.testng</groupId>
            <artifactId>testng</artifactId>
            <version>6.9.10</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.seleniumhq.selenium</groupId>
            <artifactId>selenium-java</artifactId>
            <version>4.0.0-alpha-6</version>
        </dependency>
        <dependency>
            <groupId>org.testng</groupId>
            <artifactId>testng</artifactId>
            <version>6.8.8</version>
        </dependency>
        <dependency>
            <groupId>org.seleniumhq.selenium</groupId>
            <artifactId>selenium-chrome-driver</artifactId>
            <version>4.0.0-alpha-6</version>
        </dependency>
        <dependency>
            <groupId>io.github.bonigarcia</groupId>
            <artifactId>webdrivermanager</artifactId>
            <version>RELEASE</version>
            <scope>test</scope>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.slf4j/slf4j-nop -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-nop</artifactId>
            <version>1.7.28</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.0</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <version>2.12.4</version>
            </plugin>
        </plugins>
    </build>
</project>

我们使用 IntelliJ 进行开发。您可以使用 Eclipse 或任何首选的 IDE 进行开发。

代码演练

@BeforeClass 注解下的实现设置了 Chrome 浏览器的浏览器功能。

@BeforeClass
    public void testSetUp() {
        WebDriverManager.chromedriver().setup();
        driver = new ChromeDriver();

测试用例 test_Selenium4_ToDoApp() 在@test注解下实现。诸如 find_element_by_name()、driver.find_element_by_id() 等 Selenium 方法用于定位必须对其执行操作的 Web 元素。诸如 click()、sendKeys() 等 Selenium 命令应用于必要的 Web 元素。

@Test
    public void test_Selenium4_ToDoApp() throws InterruptedException {
        driver.navigate().to(URL);
        driver.manage().window().maximize();

    try {
            ...............
            ...............
        }

Jenkins 中的声明式管道示例

在什么是 Jenkins 博客的这一部分中,我们演示了用于 Maven 项目的声明式 Jenkins 管道的用法。

设置项目

执行以下步骤来设置项目:

[ 声明性管道演示 ](https://res.cloudinary.com/practicaldev/image/fetch/s--Wiql4zmp--/c_limit%2Cf_auto%2Cfl_progressive%2Cq_auto%2Cw_880/https://www.lambdatest .com/blog/wp-content/uploads/2020/09/Declarative-Pipeline-Demonstration.png)

通过导航到 pluginManager 安装以下 Jenkins 插件,即 localhost:/pluginManager/

蓝海插件 –https://plugins.jenkins.io/blueocean
Blue Ocean Pipeline Editor Plugin –https://plugins.jenkins.io/blueocean-pipeline-editor
配置为代码插件 –https://plugins.jenkins.io/config-file-provider
JUnit 插件 –https://plugins.jenkins.io/junit/
HTML Publisher 插件 –https://plugins.jenkins.io/htmlpublisher
Maven 集成插件 –https://plugins.jenkins.io/maven-plugin
Maven 信息插件 –https://plugins.jenkins.io/maven-info
Maven SureFire 插件 –https://maven.apache.org/surefire/maven-surefire-plugin/
Blue Ocean 插件的管道实现 -https://plugins.jenkins.io/blueocean-pipeline-api-impl
管道 Maven 集成插件 –https://plugins.jenkins.io/pipeline-maven

通过导航到“系统配置”部分中的“配置系统”来配置全局设置和路径(用于 Java 和 Maven)。

[ 配置设置 ](https://res.cloudinary.com/practicaldev/image/fetch/s--i5HJjHXG--/c_limit%2Cf_auto%2Cfl_progressive%2Cq_auto%2Cw_880/https://www.lambdatest. com/blog/wp-content/uploads/2020/09/image41.png)

导航到标题为“全局属性”的配置项并添加以下环境变量:

JAVA_HOME - <安装JDK的位置>
MAVEN_HOME – <Maven安装位置>

在我们的例子中,条目如下:

JAVA_HOME – C:\Program Files\Java\jdk1.8.0_251
MAVEN_HOME – C:\apache-maven\apache-maven-3.6.3\

单击应用并保存。

添加的环境变量将在Pipeline中使用。

[ 环境变量 ](https://res.cloudinary.com/practicaldev/image/fetch/s--OUG9VfQu--/c_limit%2Cf_auto%2Cfl_progressive%2Cq_auto%2Cw_880/https://www.lambdatest. com/blog/wp-content/uploads/2020/09/environment-variables.png)

在系统配置部分添加这些环境变量会使设置公开(即它可以在 Jenkins 中的不同作业中使用)。

有了这个,我们都准备好编写我们的第一个声明性管道!

编写声明性管道

在标题为“Jenkins 声明式管道演示”的项目中,单击配置。在项目配置窗口中,单击 Pipeline 选项卡。

[ Jenkins 声明 ](https://res.cloudinary.com/practicaldev/image/fetch/s--TuEtWx4W--/c_limit%2Cf_auto%2Cfl_progressive%2Cq_auto%2Cw_880/https://www.lambdatest. com/blog/wp-content/uploads/2020/09/Jenkins-Declarative.png)

在管道“定义”下,选择管道脚本。将以下 Jenkinsfile 的内容粘贴到脚本框中。单击应用并保存。

pipeline {
    agent any
    tools {
        maven 'MAVEN_3.6.3'
        jdk 'JDK_1.8.0_251'
    }
    stages {
        stage('Build') {
            environment {
                PROJECT_DIR = "C:\\Users\\Lenovo\\IdeaProjects\\CrossBrowserTest"
            }
            steps {
                echo 'maven clean'
                bat ' mvn -f %PROJECT_DIR%\\pom.xml clean install'  
            }
        }
    }
    post {
            success {
                        echo 'Now Archiving'
                        junit allowEmptyResults: true, testResults: '**/surefire-reports/*.xml'
                }
        }
}

管道演练

这个特定的 Jenkins 作业可以在任何代理上运行。

pipeline {
    agent any

定义工具指令的部分列出了必须自动安装的工具。同样的也被添加到 PATH 变量中。如果未指定代理,则此部分将被忽略。

tools {
        maven 'MAVEN_3.6.3'
        jdk 'JDK_1.8.0_251'
    }

在我的机器上,安装了 JDK 版本 1.8.0_251 和 Maven 版本 3.6.3。因此,在 tools 指令下添加了指向各自 Maven 和 JDK 版本的别名 maven 和 jdk。

管道中只有一个“构建”阶段。使用 environment 指令,我们定义了一个指向包含 Java 项目的目录的环境变量。定义的环境变量(即_PROJECT_DIR_)将可用于所有步骤或特定于阶段的步骤,因为它是在阶段“构建”中定义的。

[](https://res.cloudinary.com/practicaldev/image/fetch/s--6UCmpuK3--/c_limit%2Cf_auto%2Cfl_progressive%2Cq_auto%2Cw_880/https://www.lambdatest.com /blog/wp-content/uploads/2020/09/PROJECT_DIR.png)

stage('Build') {
            environment {
                PROJECT_DIR = "C:\\Users\\Lenovo\\IdeaProjects\\CrossBrowserTest"
            }

这一步是定义 Jenkins Pipeline 最重要的一步,因为在这一步执行构建。命令 mvn clean install 在项目目录中的 pom.xml 上执行。由于我们的构建机器是 Windows,因此我们通过 bat(或批处理)调用构建命令。

steps {
                echo 'maven clean'
                //ABC indicates the folder name where the pom.xml file resides
                bat ' mvn -f %PROJECT_DIR%\\pom.xml clean install'  
            }

在“post”指令下添加了构建后操作。只有在构建过程成功时才会调用该操作,因为这些操作处于“成功”状态。 junit 插件用于准备测试报告。

post {
            success {
                        echo 'Now Archiving'
                        junit allowEmptyResults: true, testResults: '**/surefire-reports/*.xml'
                }
        }
}

一旦我们将管道添加到 Jenkinsfile 中,单击“Open Blue Ocean”链接以运行该作业。或者,您也可以通过单击“立即构建”选项发出构建,在这种情况下,您无需安装 Blue Ocean 插件。

[ jenkins 管道 ](https://res.cloudinary.com/practicaldev/image/fetch/s--bpC43792--/c_limit%2Cf_auto%2Cfl_progressive%2Cq_auto%2Cw_880/https://www.lambdatest. com/blog/wp-content/uploads/2020/09/jenkins-pipeline.png)

单击“运行”以运行作业。

[ 设置主从 ](https://res.cloudinary.com/practicaldev/image/fetch/s--04CsLleU--/c_limit%2Cf_auto%2Cfl_progressive%2Cq_auto%2Cw_880/https://www. lambdatest.com/blog/wp-content/uploads/2020/09/image40.png)

如下图,工具(即JDK和Maven)配置成功。

[ JDK 和 Maven ](https://res.cloudinary.com/practicaldev/image/fetch/s--LPB0Pf1I--/c_limit%2Cf_auto%2Cfl_progressive%2Cq_auto%2Cw_880/https://www.lambdatest .com/blog/wp-content/uploads/2020/09/JDK-and-Maven.png)

“构建”步骤和构建后操作运行没有任何问题。

[ 步骤 'Build ](https://res.cloudinary.com/practicaldev/image/fetch/s--b20JFFWO--/c_limit%2Cf_auto%2Cfl_progressive%2Cq_auto%2Cw_880/https://www.lambdatest .com/blog/wp-content/uploads/2020/09/Steps-%25E2%2580%2598Build.png)

这是当前 Jenkins 流水线的阶段视图。声明性工具安装阶段在 2 秒内完成,构建阶段用时 3 分 25 秒。

[ 步骤 'Build ](https://res.cloudinary.com/practicaldev/image/fetch/s--xB0wBNQl--/c_limit%2Cf_auto%2Cfl_progressive%2Cq_auto%2Cw_880/https://www.lambdatest .com/blog/wp-content/uploads/2020/09/Steps-%25E2%2580%2598Build-1.png)

您可以将鼠标悬停在任何阶段并查看该特定阶段的日志。如控制台输出所示,测试场景已成功执行,其中 Chrome WebDriver 被实例化,并且在被测网页上执行了所需的操作。

[](https://res.cloudinary.com/practicaldev/image/fetch/s--G1gZkRN---/c_limit%2Cf_auto%2Cfl_progressive%2Cq_auto%2Cw_880/https://www.lambdatest.com /blog/wp-content/uploads/2020/09/image49.png)

截断的控制台日志如下:

[INFO] --- maven-compiler-plugin:3.0:testCompile (default-testCompile) @ org.selenium4.CrossBrowserTest ---
[INFO] Changes detected - recompiling the module!
[INFO] Compiling 1 source file to C:\Users\Lenovo\IdeaProjects\CrossBrowserTest\target\test-classes
[INFO] 
[INFO] --- maven-surefire-plugin:2.12.4:test (default-test) @ org.selenium4.CrossBrowserTest ---
[INFO] Surefire report directory: C:\Users\Lenovo\IdeaProjects\CrossBrowserTest\target\surefire-reports

-------------------------------------------------------
 T E S T S
-------------------------------------------------------
Running org.selenium4.CrossBrowserTest
Configuring TestNG with: org.apache.maven.surefire.testng.conf.TestNG652Configurator@299a06ac
Starting ChromeDriver 84.0.4147.30 (48b3e868b4cc0aa7e8149519690b6f6949e110a8-refs/branch-heads/4147@{#310}) on port 45010
Only local connections are allowed.
Please see https://chromedriver.chromium.org/security-considerations for suggestions on keeping ChromeDriver safe.
ChromeDriver was started successfully.
[1595945821.200][WARNING]: Timed out connecting to Chrome, retrying...
Jul 28, 2020 7:47:03 PM org.openqa.selenium.remote.ProtocolHandshake createSession
INFO: Detected dialect: W3C
Demonstration of Jenkins is complete
Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 93.655 sec

Results :

Tests run: 1, Failures: 0, Errors: 0, Skipped: 0

Jenkins 中的 Maven 项目示例

接下来在这篇什么是 Jenkins 博客中,我们将深入探讨如何将 Maven 与 Jenkins 结合使用。 Jenkins 中的 Maven 项目利用了 POM 文件并减少了在项目配置上花费的整体工作量。

设置项目

执行以下步骤来设置 Maven 项目:

[ Jenkins ](https://res.cloudinary.com/practicaldev/image/fetch/s--I-c6zFVF--/c_limit%2Cf_auto%2Cfl_progressive%2Cq_auto%2Cw_880/https://www.lambdatest .com/blog/wp-content/uploads/2020/09/image47.png)

通过导航到 pluginManager 安装以下 Jenkins 插件,即http://localhost:< port_associated_with_Jenkins >/pluginManager/。还为 Jenkins Pipeline 演示安装了相同的插件集。

蓝海插件 –https://plugins.jenkins.io/blueocean
Blue Ocean Pipeline Editor Plugin –https://plugins.jenkins.io/blueocean-pipeline-editor
配置为代码插件 –https://plugins.jenkins.io/config-file-provider
JUnit 插件 –https://plugins.jenkins.io/junit/
HTML Publisher 插件 –https://plugins.jenkins.io/htmlpublisher
Maven 集成插件 –https://plugins.jenkins.io/maven-plugin
Maven 信息插件 –https://plugins.jenkins.io/maven-info
Maven SureFire 插件 –https://maven.apache.org/surefire/maven-surefire-plugin/
Blue Ocean 插件的管道实现 –https://plugins.jenkins.io/blueocean-pipeline-api-impl
管道 Maven 集成插件 –https://plugins.jenkins.io/pipeline-maven

现在,转到构建选项卡并在根 POM 和目标和选项中输入详细信息。在 Root POM 中,输入项目 pom.xml 所在目录的位置。我们在目标和选项中输入干净测试,以便执行干净的构建。

根 POM – <项目目录>\pom.xml
目标和选项 – 清洁测试

[ 目标和选项 ](https://res.cloudinary.com/practicaldev/image/fetch/s--dKRdK5gI--/c_limit%2Cf_auto%2Cfl_progressive%2Cq_auto%2Cw_880/https://www.lambdatest .com/blog/wp-content/uploads/2020/09/unnamed.png)

构建后,如果需要测试报告,您可以在 Post Steps 选项卡中添加相关的“添加构建后步骤”。

单击应用并保存。单击立即构建(或从“打开蓝海”中选择相同的项目)开始构建过程。

[ 保存按钮 ](https://res.cloudinary.com/practicaldev/image/fetch/s--6dG3Xpbj--/c_limit%2Cf_auto%2Cfl_progressive%2Cq_auto%2Cw_880/https://www.lambdatest. com/blog/wp-content/uploads/2020/09/Apply-and-Save.png)

从控制台日志中可以看出,测试已成功执行。

[INFO] --- maven-resources-plugin:2.6:testResources (default-testResources) @ org.selenium4.CrossBrowserTest ---
[INFO] Using 'UTF-8' encoding to copy filtered resources.
[INFO] skip non existing resourceDirectory C:\Users\Lenovo\IdeaProjects\CrossBrowserTest\src\test\resources
[INFO] 
[INFO] --- maven-compiler-plugin:3.0:testCompile (default-testCompile) @ org.selenium4.CrossBrowserTest ---
[INFO] Changes detected - recompiling the module!
[INFO] Compiling 1 source file to C:\Users\Lenovo\IdeaProjects\CrossBrowserTest\target\test-classes
[INFO] 
[INFO] --- maven-surefire-plugin:2.12.4:test (default-test) @ org.selenium4.CrossBrowserTest ---
[INFO] Surefire report directory: C:\Users\Lenovo\IdeaProjects\CrossBrowserTest\target\surefire-reports

-------------------------------------------------------
 T E S T S
-------------------------------------------------------
Running org.selenium4.CrossBrowserTest
Configuring TestNG with: org.apache.maven.surefire.testng.conf.TestNG652Configurator@299a06ac
Starting ChromeDriver 84.0.4147.30 (48b3e868b4cc0aa7e8149519690b6f6949e110a8-refs/branch-heads/4147@{#310}) on port 39047
Only local connections are allowed.
Please see https://chromedriver.chromium.org/security-considerations for suggestions on keeping ChromeDriver safe.
ChromeDriver was started successfully.
[1595948996.334][WARNING]: Timed out connecting to Chrome, retrying...
[1595949004.487][WARNING]: Timed out connecting to Chrome, retrying...
Jul 28, 2020 8:40:15 PM org.openqa.selenium.remote.ProtocolHandshake createSession
INFO: Detected dialect: W3C
Demonstration of Jenkins is complete
Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 94.51 sec
Results :

Tests run: 1, Failures: 0, Errors: 0, Skipped: 0

Jenkins的优缺点

我们希望这篇“什么是 Jenkins”博客能帮助您从更实际的意义上理解 CI 服务器。在你加入 Jenkins 潮流之前,了解它的优点和缺点是很重要的。我们已将它们列出以使您更容易选择-

詹金斯的优势

下面列出了使用 Jenkins 的一些显着优势:

Jenkins 是开源的并且可以免费使用。它是早期创业公司和大公司首选的 CI/CD 工具,因为它已经开发了很长时间。
它是一个丰富的插件生态系统。在撰写本文时,有近 1500 多个插件可供使用。
Jenkins 可以与流行的云平台集成,例如 Amazon EC2、Google Cloud、VMWare vSphere、Digital Ocean 等。
Jenkins Pipelines 对于实现大型项目的 CD 需求非常有用。

詹金斯的缺点

Jenkins 也有自己的缺点(不一定是缺点)。这些是 Jenkins 的一些主要缺点:

作为一个产品,Jenkins 更加“功能”驱动和“开发人员”为中心。痴迷于用户界面的用户可能必须经历一段学习曲线才能使用 Jenkins。
设置更改(包括插件安装)可能会导致 Jenkins 无法启动等问题。在这种情况下,您必须在线搜索解决方案,幸运的是您会找到一个解决方案,因为 Jenkins 拥有庞大的用户群!

总的来说,Jenkins 是一个真正为开发人员打造的强大 CI/CD 工具!

这是一个包装

我们感谢您努力关注这个冗长的“詹金斯是什么”博客并走到这一步! Jenkins 是一个出色的 CI/CD 工具,具有出色的功能,最好的部分是它可以免费使用。根据我们在什么是 Jenkins 博客中讨论的内容,我们可以得出结论,Jenkins 具有通过提供 CI 服务来提高发布敏捷性的功能。

Jenkins Pipeline 是增强 Jenkins 产品的另一个功能,因为它允许您使用领域特定语言 (DSL) 实现管道即代码。尽管市场上还有其他 CI/CD 工具,但 Jenkins 凭借其社区和强大的功能集(尤其是 Jenkins Pipeline)蓬勃发展,这些功能通过 CI 工具提供更快的反馈。

插件、可扩展性和在线社区是 Jenkins 的核心 USP。为了提高 Jenkins 等工具的可用性和功能,您可以使用基于云的跨浏览器测试平台。一个这样的平台是 LambdaTest,它还提供LambdaTest Jenkins 插件来加速您的自动化浏览器测试活动。使用 LambdaTest,您可以在 2000 多种浏览器、操作系统和设备的组合上执行测试。快乐测试!

CI/CD

CI/CD社区为您提供最前沿的新闻资讯和知识内容

更多推荐

Jenkins环境变量、参数及groovy脚本使用介绍。

这是系列中的第三篇文章使用 Jenkins 将 Django 应用程序部署到 AWS EC2 实例。 Jenkins的温和指南。在本文中,我们将介绍如何在 Jenkins 中使用变量和参数以及如何使用 groovy 脚本。我们将使用与以前相同的项目。您需要事先阅读过之前的文章。 1.如何在 JenkinsFile 中配置和使用变量。在编写 JenkinsFile 管道脚本时,您可能需要注入和

CI/CD

Rust 中的 OpenTelemetry 分布式跟踪指南

在本文中,我将分享我将 OpenTelemetry 分布式跟踪添加到 Rust 应用程序的经验。我将尝试回答以下问题: 如何在 Rust 中检测 Opentelemetry? 如何在 Rust 应用程序中添加手动和自动检测? 如何使用tracing来调试Rust应用? 如何可视化跟踪和跨度? 如何在多线程环境中保存我们的 span 上下文? 在 Rust 中进行跟踪时,你必须知道哪些 crat

CI/CD

Jenkins 管道,用于构建 Django 映像并将其推送到 dockerhub 和 GitHub webhook 集成。

这是系列文章的第四篇使用 Jenkins 将 Django 应用程序部署到 AWS EC2 实例。詹金斯的温和指南。在本文中,您将拼凑您所学的所有基础知识,并构建一个完整的 Jenkins 管道,该管道将构建 Django 映像并将其部署到 Dockerhub。您需要事先阅读过之前的文章 1.添加 init 阶段并加载script.groovy文件。在您的 JenkinsFile 中,添加加

CI/CD

所有评论(0)

查看更多评论

weixin_0010034

@coc_devpress_01

已为社区贡献22912条内容

什么是詹金斯?如何以及为什么要使用它?

weixin_0010034

什么是詹金斯?

詹金斯的历史

Jenkins 发布周期

詹金斯的显着特点

1\。易于安装和配置

2\。开源

3\。蓬勃发展的插件生态系统

4\。易于分发

詹金斯是如何工作的?

詹金斯的架构

Jenkins 中的主从架构

詹金斯大师

詹金斯奴隶

Jenkins在主从架构中是如何工作的?

如何安装詹金斯?

Jenkins 安装的先决条件

在 Windows 10 上安装 Jenkins(使用 Jenkins 安装程序)的步骤

在 Windows 10 上安装 Jenkins(使用 .war)的步骤

如何配置Jenkins?

Jenkins 中的用户管理

在 Jenkins 中为用户分配角色

如何在 Jenkins 中设置主从?

创建从属(或代理)的先决条件

在 Jenkins 中创建从站的步骤

什么是 Jenkins 流水线?

什么是 Jenkinsfile?

定义 Jenkinsfile 的语法

a。声明式

b。脚本

Jenkins Pipeline的重要概念

a。管道

b。节点

c。阶段

d。步

使用Jenkins Pipeline的优势

声明性管道样本

詹金斯示范

测试场景

Jenkins 中的声明式管道示例

设置项目

编写声明性管道

管道演练

Jenkins 中的 Maven 项目示例

设置项目

Jenkins的优缺点

詹金斯的优势

詹金斯的缺点

这是一个包装

所有评论(0)

温馨提示：您尚未绑定手机号

weixin_0010034