Jenkins的使用

文章目录

一、Jenkins是什么\有什么用\与GitLab的对比
二、Jenkins的安装与配置
- Jenkins的安装方式
- - 在Linux上安装Jenkins：
  - 在Windows上安装Jenkins：
  - 配置Jenkins：
- （可选）配置启动用户为root（一定要是root吗??何时需要root?）
- - 对于Jenkins WAR文件运行方式：
  - 对于Jenkins服务运行方式（使用init脚本或systemd）：
  - 注意事项：
- （可选）配置提升的Jenkins的插件的下载速度下载源
- 配置Jenkins的插件
- - Git插件
  - - 1. 安装Git插件
    - 2. 推荐的Git相关插件
    - 3. 手动下载并安装插件
    - 4. 配置Git
    - 5. 配置项目使用Git
  - GitLab插件
  - - 1. 安装GitLab插件
    - 2. 推荐的GitLab相关插件
    - 3. 配置Jenkins与GitLab的集成
    - 4. 配置Jenkins作业
    - 5. 配置GitLab Webhook
  - Maven插件
  - - 1. 安装Maven插件
    - 2. 推荐的Maven相关插件
    - 3. 配置Jenkins与Maven
    - 4. 配置Jenkins作业使用Maven
    - 5. 全局工具配置
  - SSH插件
  - - 1. 安装SSH插件
    - 2. 推荐的SSH相关插件
    - 3. 配置SSH服务器
    - 4. 测试SSH连接
    - 5. 在Jenkins Job中使用SSH插件
  - Sonar插件
  - - 什么是SonarQube
    - Jenkins的Sonar插件有什么用
    - 1. 安装SonarQube插件
    - 2. 配置SonarQube服务器
    - 3. 配置Jenkins项目使用SonarQube
    - 4. 编写Jenkinsfile（可选）
    - 5. 构建项目
    - 6. 配置质量门限（可选）
  - Pipeline插件
  - - 1. 了解Pipeline的基本概念
    - 2. 创建Pipeline项目
    - 3. 编写Pipeline脚本
    - 4. 安装Pipeline相关插件
    - 5. 下载插件
  - 通过本地文件安装插件
*三-pre、代码上线大致流程
- GitLab中创建项目
- 创建分支
- 可以配置分支保护避免其他人随便访问修改
- 提交代码到对应的分支
- 提交审核工单是否将分支合并
- 从GitLab中的拉取对应的仓库版本代码
- 后端代码编译构建
- 使用工具(sonarqube)代码质量检测
- 灰度发布
- - 在负载均衡器上摘除需要更新的机器
  - 将代码推送到那个需要更新的机器的站点目录
  - 绑定测试域名对代码进行功能等测试
  - 如果测试没有问题就将该机器重新接入负载均衡器中
  - 如果有问题那么回滚
三、Jenkins与GitLab仓库配合实现将Web应用代码自动化部署到Web服务器
- 三-1、基本流程
- - 1. 配置GitLab
  - 2. Jenkins与GitLab集成
  - 3. 创建Jenkins项目
  - 4. 配置构建和部署
  - 5. 配置Webhook
  - 6. 构建和部署
  - 7. 监控和日志
- 三-2、能否单独使用GitLab实现上面的自动化部署到Web服务器
- - 1. 创建`.gitlab-ci.yml`文件
  - 2. 定义构建和部署步骤
  - 3. 配置部署凭据
  - 4. 触发CI/CD管道
  - 5. 监控部署
  - 6. 处理部署失败
- 三-3、Jenkins使用Shell脚本+参数化构建过程
- - *不使用“参数化构建传参给脚本”的脚本
  - Jenkins的参数化构建是什么及具体如何使用
  - - 1. 启用参数化构建过程
    - 2. 添加参数
    - 3. 在构建步骤中使用参数
    - 4. 执行shell构建步骤
    - 5. 使用参数执行shell命令
    - 6. 保存并构建项目
  - 使用“参数化构建传参给脚本”的脚本
- 三-4、Jenkins使用WebHook自动触发构建
- - 什么是Jenkins的WebHook及其实现的基本原理
  - - Webhook的基本原理
    - Jenkins Webhook配置步骤
  - Jenkins需要生成一个token、为什么要配置token
  - GitLab的WebHook和token的配合设置
  - - Webhook请求访问Gitlab本地网络错误问题：
    - 解决办法：
  - 测试GitLab的仓库改变后是否Jenkins将自动触发部署任务
四、Jenkins使用Maven插件创建构建、部署Maven项目的任务
- 四-1、Maven的介绍
- - Maven是什么
  - Maven的用途
  - 具体如何使用Maven
  - - 1. 安装Maven
    - 2. 配置Maven
    - 3. 创建Maven项目
    - 4. 编写POM文件
    - 5. 使用Maven命令
    - 6. Maven生命周期
- 四-2、*Web配置Tomcat
- - CentOS7安装Maven和JRE版本的兼容性
  - 1. 安装Tomcat
  - - 步骤1：添加Tomcat仓库
    - 步骤2：安装Tomcat
    - 步骤3：验证安装
  - 2. 配置Tomcat
  - - 步骤1：配置环境变量
    - 步骤2：配置`server.xml`
    - 步骤3：配置用户
  - 3. 启动Tomcat
  - - 步骤1：启动服务
    - 步骤2：设置开机启动
    - 步骤3：检查服务状态
  - 4. 访问Tomcat
  - 5. 部署应用
  - /usr/share/tomcat/webapps/ROOT和/var/lib/tomcat/webapps/ROOT的区别
  - Tomcat的webapps目录和webapps下的ROOT目录的区别以及Tomcat的自动部署机制
- 四-3、Jenkins上安装与配置Maven
- - 修改Maven的下载源以便提升下载速度
- 四-4、Jenkins对从gitLab中获取到的Java项目使用Maven打包
- 四-5、将上面的maven打包好的Java应用包部署到Web服务器的站点中
- - 使用Jenkins的Maven任务的插件支持的功能实现更快的部署
  - - 1. 安装必要的插件
    - 2. 创建新任务
    - 3. 配置源码管理
    - 4. 配置构建触发器
    - 5. 配置构建环境
    - 6. 配置构建
    - 7. 配置构建后操作
    - 8. 配置Maven
    - *“全局配置”中的JDK的配置、Maven配置
    - 9. 配置Maven设置
    - 10. 保存并运行
    - 测试执行结果：
*五、SonarQube的介绍、安装与部署
- SonarQube是什么
- SonarQube的安装与配置
- - 安装SonarQube
  - 安装PostgreSQL
  - 配置启动PostgreSQL
  - - 初始化PostgreSQL
    - 启动
  - 进入PostgreSQL创建Sonar数据库及用户
  - - 必须切换到自动生成的postgres用户登录
    - 创建sonar数据库及用户
  - SonarQube和JDK、数据库版本的兼容性对比
  - - JDK兼容性
    - 数据库兼容性
    - 总结
  - 配置SonarQube并启动
  - - *配置JDK的JAVA_HOME环境变量（源码安装时）：
    - *优化系统文件描述符等参数便于提高SonarQube的运行速度：
    - 创建Sonar用户、启动SonarQube
  - 访问SonarQube页面进行下一步操作
  - - 生成Token
    - 创建SonarQube项目
五、Jenkins在Maven任务中使用SonarQube插件进行代码质检
- 五-1、基本介绍
- - 1. 安装SonarQube Scanner插件
  - 2. 配置SonarQube服务器信息
  - 3. 生成SonarQube Token
  - 4. 配置Jenkins凭证
  - 5. 配置Maven项目
  - 6. 编写Jenkins Pipeline脚本
  - 7. 构建项目
- 五-2、具体配置
- - "Pre Steps"中配置SonarQube
- 五-3、执行结果
- - 具体控制台输出信息示例：
六、Jenkins的Pipeline任务的使用
- 六-1、什么是Pipeline项目
- 六-2、Jenins的Pipeline任务的配置与使用
- - 创建Pipeline类型的任务：
  - 可以使用“流水线语法”页面自动生成不同功能对应的Pipeline脚本：
  - 详细Pipeline脚本示例
  - 执行结果查看

一、Jenkins是什么\有什么用\与GitLab的对比

Jenkins是一个开源的自动化服务器，主要用于持续集成和持续部署（CI/CD）项目。它允许团队通过自动化来加速软件开发过程，管理和控制软件交付的整个生命周期，包括构建、文档、测试、打包、部署、静态代码分析等。

Jenkins的前身是Hudson，由Sun公司在2004年启动，并于2005年发布了第一个版本。 Hudson在2007年开始逐渐取代其他开源构建工具，成为持续集成领域的主流工具。然而，在2010年Oracle收购Sun公司后，由于商标名称“Hudson”的所有权问题，项目的主要贡献者和Oracle之间产生了分歧。因此，在2011年1月，社区投票决定将项目名称从“Hudson”更改为“Jenkins”。

关于Jenkins名字的由来，它来源于一个叫做"Servant Jenkins"的虚构角色，他是一位绅士的仆人。这个名称旨在反映出Jenkins工具的主要目的：为开发者提供服务。这个名字象征着Jenkins作为一个服务于开发者的工具，帮助他们自动化构建和部署流程。

Jenkins是一个开源的自动化服务器，主要用于构建、测试和部署软件项目。它提供了一个易于使用的界面，可以通过简单的配置来实现持续集成和持续交付。Jenkins的主要功能包括自动化构建、测试和报告、持续集成、自动化部署以及可扩展性。Jenkins的主要用途包括持续集成和持续交付、自动化测试等。

GitLab是一个集成了版本控制、持续集成/持续交付(CI/CD)、项目管理和协作的完整DevOps平台。GitLab CI/CD用于存储和管理代码、自动化CI/CD流程、跟踪问题、保护代码安全和协作。

Jenkins与GitLab的对比：

集成与自动化：
- Jenkins是一个高度可定制的自动化服务器，可以与各种工具和服务集成，如Git、GitHub、Bitbucket等。
- GitLab提供了与GitLab其他功能的紧密集成，包括代码管理、问题跟踪、代码审查等。
易于使用：
- GitLab提供了一个简单直观的用户界面，使得CI/CD管道的设置和配置更加容易。
- Jenkins虽然功能强大，但需要一定的技术专业知识来设置和配置，学习曲线较陡峭。
性能：
- GitLab以其快速、可靠的性能而闻名，具有内置的缓存和并行处理功能。
- Jenkins在运行大型且复杂的管道时可能会遇到性能问题，需要手动优化以确保性能。
安全：
- GitLab具有内置的安全功能，提供代码扫描、漏洞管理和容器扫描等功能。
- Jenkins严重依赖插件来实现安全功能，这可能会使确保管道安全变得具有挑战性。
成本：
- GitLab提供免费和付费计划，免费计划包括小团队CI/CD所需的大部分功能。
- Jenkins是一个开源工具，可以免费使用，但设置和维护可能需要大量资源，这可能会增加总体成本。
社区和支持：
- Jenkins拥有一个大型且活跃的社区，提供广泛的文档、插件和资源。
- GitLab也有一个不断增长的社区，并提供商业支持选项。

总的来说，Jenkins和GitLab CI/CD都是强大的CI/CD工具，选择哪一个取决于你的具体需求和偏好。GitLab提供了一个集成的解决方案，而Jenkins则更加灵活，可以通过插件进行定制。

Jenkins是一个开源的自动化服务器，它主要用于自动化各种任务，包括构建、测试和部署软件项目。以下是Jenkins实现自动化部署的具体方法和步骤：

安装与启动：
- 首先，确保服务器已安装Java环境，然后下载Jenkins的WAR包进行安装。在命令行中执行java -jar jenkins.war来启动Jenkins。启动成功后，通过浏览器访问http://localhost:8080即可看到Jenkins的欢迎页面。
配置网络与安全：
- 在初次使用Jenkins时，需要设置管理员账号和密码。设置完成后，进入系统设置，配置网络设置和代理设置（如果有需要）。
安装插件：
- 为了实现自动化部署，需要安装一些插件来支持工作。例如，安装Git插件来支持从Git仓库获取代码。在“管理插件”页面搜索并安装所需的插件。
配置构建任务：
- 在Jenkins中，构建任务是通过“新建构建任务”来创建的。选择“自由风格”项目，然后填写项目名称。在“配置”页面中，需要配置源码管理、构建触发器和构建环境三个部分。
配置构建步骤：
- 在构建步骤中，可以配置自动化部署的具体操作。例如，使用“执行shell”步骤来运行一些命令，这些命令可以是自动化部署脚本或命令行指令。
查看构建结果：
- 配置完成后，保存并开始构建任务。构建结果会显示在Jenkins主页上。如果构建失败，可以通过查看日志来诊断问题。如果需要查看更详细的日志信息，可以打开Jenkins的Web界面并查看相应构建任务的日志。
持续集成与持续部署（CI/CD）：
- 通过Jenkins自动化部署的实践，可以逐渐完善CI/CD流程。通过自动化测试和静态代码分析来保证代码质量，通过自动化部署来提高开发效率。同时，还可以通过Jenkins的插件和扩展来实现更多的功能，例如蓝绿部署、灰度发布等。
使用Pipeline：
- Jenkins的Pipeline功能可以将构建、测试、打包、部署等步骤串联起来，自动化地将应用程序从开发环境推送到生产环境。Pipeline通过Jenkinsfile定义，可以在源码管理系统中进行版本控制。
主从架构：
- Jenkins的主从架构允许在多台机器上分布构建任务，提高构建和部署的效率。
插件支持：
- Jenkins拥有广泛的插件支持，这些插件可以扩展Jenkins的功能，包括自动化部署、安全、报告等。

通过这些步骤和功能，Jenkins能够实现从代码提交到自动上线的全流程自动化，减少人为错误，提升软件发布的效率和质量。

Jenkins是一个功能强大的自动化服务器，适用于多种类型的项目，尤其是那些需要频繁构建、测试和部署的软件开发项目。以下是一些特别适合使用Jenkins的项目类型：

大型软件开发项目：对于规模较大、复杂度较高的软件开发项目，Jenkins提供了强大的自动化构建和测试能力，能够显著提高开发效率和质量。
持续集成/持续部署（CI/CD）项目：Jenkins是CI/CD流程的核心工具之一，能够自动化地从代码仓库中获取代码更改，触发构建任务，运行测试，并将软件部署到指定的环境中。
多语言、多技术栈项目：Jenkins支持多种编程语言和工具，通过丰富的插件生态系统，可以轻松扩展其功能，支持各种开发流程和工具的集成，因此特别适合那些涉及多种语言和技术栈的项目。
需要频繁迭代和发布的项目：对于需要快速迭代和发布的项目，如互联网产品、移动应用等，Jenkins的自动化构建和部署能力能够显著缩短发布周期，提高响应速度。
对构建和测试环境有严格要求的项目：Jenkins提供了丰富的构建配置选项，允许用户自定义构建步骤、触发器、构建后操作和通知机制，因此特别适合那些对构建和测试环境有严格要求的项目。
需要分布式构建的项目：Jenkins支持分布式构建，可以将构建任务分发到多个节点上并行执行，从而提高构建效率。这对于大型项目或需要处理大量构建任务的项目来说是一个显著的优势。
需要详细构建和测试报告的项目：Jenkins提供了详细的构建历史和工作流视图，以及构建和测试的报告生成功能，这对于需要详细跟踪和记录构建和测试过程的项目来说非常有用。
需要与其他工具集成的项目：Jenkins具有强大的插件机制，可以与各种版本控制系统、构建工具、测试框架、通知系统等集成，因此特别适合那些需要与其他工具协同工作的项目。

总的来说，Jenkins适用于那些需要高度自动化、频繁迭代和发布、对构建和测试环境有严格要求、需要详细构建和测试报告以及需要与其他工具集成的软件开发项目。通过合理配置和使用Jenkins，可以显著提高项目的开发效率和质量，降低人工操作的风险和成本。

二、Jenkins的安装与配置

Jenkins的安装方式

Jenkins的安装与配置可以根据不同操作系统和环境有所不同。以下是在不同环境下安装和配置Jenkins的一般步骤：

官网权威的安装方式：RedHat系列的Jenkins的安装

在Linux上安装Jenkins：

安装Java：
Jenkins需要Java环境，因此首先需要安装Java。对于大多数Linux发行版，可以使用包管理器安装Java。
```
sudo apt-get update
sudo apt-get install openjdk-11-jdk
```

Jenkins和JDK各版本的兼容性：
在这里插入图片描述
具体见官网：Java Support Policy

下载Jenkins：
访问Jenkins官方网站下载最新版本的Jenkins WAR文件。
启动Jenkins：
使用Java命令启动Jenkins。
```
java -jar jenkins.war
```

在这里插入图片描述

这将在http://localhost:8080启动Jenkins。

解锁Jenkins：
第一次启动Jenkins时，需要解锁。访问http://localhost:8080，页面会显示一个初始管理员密码。这个密码可以在/var/lib/jenkins/secrets/initialAdminPassword文件中找到（对于Linux）。复制这个密码并粘贴到Jenkins的解锁页面。

如：96877ec39fb541ca86389e6ce6fd20cd
安装推荐的插件：
解锁后，Jenkins会提示你安装推荐的插件。可以选择安装或稍后手动安装。
创建管理员用户：
创建一个管理员用户，输入用户名和密码。
完成安装：
完成上述步骤后，Jenkins安装完成，可以开始使用。

在Windows上安装Jenkins：

安装Java：
下载并安装Java运行环境（JRE）或Java开发工具包（JDK）。
下载Jenkins：
从Jenkins官网下载Windows版本的安装程序。
运行安装程序：
双击下载的.msi文件，按照提示完成安装。
启动Jenkins服务：
安装完成后，Jenkins将自动启动。你也可以通过Windows服务管理器手动启动Jenkins服务。
访问Jenkins：
在浏览器中访问http://localhost:8080，按照Linux安装中的步骤解锁Jenkins、安装插件和创建管理员用户。

配置Jenkins：

系统配置：
- 在Jenkins的系统配置页面，可以设置Jenkins的全局配置，如Jenkins URL、构建历史记录、系统消息等。
安装插件：
- 在“管理Jenkins” > “管理插件”中，可以安装、更新和管理插件。
配置工具：
- 在“管理Jenkins” > “全局工具配置”中，可以配置JDK、Maven、Git等工具的路径。
设置权限：
- 在“管理Jenkins” > “管理用户”中，可以添加用户和设置权限。
创建新任务：
- 在Jenkins首页，点击“新建”来创建新的任务（Job）。配置任务的源码管理、构建触发器、构建环境等。
配置构建步骤：
- 在任务配置中，添加构建步骤，如执行shell脚本、调用Gradle/Maven等。
配置后构建操作：
- 在任务配置中，设置构建成功后的操作，如发送通知、发布Javadoc等。
使用Pipeline：
- 对于复杂的构建流程，可以使用Jenkins Pipeline来定义和执行构建流程。
备份和恢复：
- 定期备份Jenkins的数据和配置，以便在需要时恢复。
监控和日志：
- 监控Jenkins的性能和日志，以便及时发现和解决问题。

这些步骤提供了Jenkins安装和配置的基本框架。根据具体需求，可能还需要进行更详细的配置和优化。

（可选）配置启动用户为root（一定要是root吗??何时需要root?）

在这里插入图片描述
配置Jenkins的启动用户为root并不是必要的，而且在大多数情况下，这是不推荐的做法。以下是几个关键点来解释为什么：

安全性：运行Jenkins（或任何服务）作为root用户会带来安全风险。如果Jenkins的进程被恶意利用，攻击者将拥有root权限，这可能导致系统被完全控制。因此，出于安全考虑，最好以非root用户运行Jenkins。
权限管理：Jenkins在执行构建任务时可能需要访问文件系统和其他资源。如果Jenkins以root用户运行，它将拥有对系统的完全访问权限，这可能会导致不必要的权限过度，增加了误操作和安全风险。相反，可以通过配置适当的权限和使用sudoers文件来安全地授权Jenkins执行需要更高权限的操作。
最佳实践：在Linux系统中，最佳实践是尽可能以非特权用户运行服务。这样可以限制服务的权限，减少潜在的损害。如果Jenkins需要执行特定的命令或访问特定的文件，可以通过配置文件系统权限或使用sudo来实现，而不是将整个Jenkins服务以root用户运行。
灵活性和控制：使用非root用户运行Jenkins可以提供更好的灵活性和控制。例如，可以为Jenkins用户配置特定的sudo权限，允许它执行特定的管理任务，而不需要全局root权限。
系统和Jenkins的配置：大多数Jenkins的安装和配置指南推荐使用默认的jenkins用户，而不是root。这是因为Jenkins的Omnibus包（用于Red Hat和Debian系统）已经预配置了jenkins用户和组，并且提供了适当的权限设置。

综上所述，配置Jenkins的启动用户为root并不是必要的，也不是推荐的做法。应该遵循安全最佳实践，以非root用户运行Jenkins，并在需要时通过适当的权限管理策略来授权Jenkins执行特定的任务。

配置Jenkins的启动用户为root并不是常规推荐的做法，因为这会带来安全风险。然而，在某些特定的场景下，可能需要将Jenkins配置为以root用户运行。以下是一些可能需要配置JENKINS_USER="root"的情况：

权限问题：在构建项目后需要执行一些需要root权限的shell命令时，可能会出现权限不足的情况，导致构建失败。在这种情况下，为了解决权限问题，可能会将Jenkins的启动用户设置为root。
Docker和Kubernetes操作：当Jenkins和Kubernetes master安装在同一台机器上，并且需要通过Jenkins pipeline执行shell命令来更新已经运行的容器时，由于k8s通常是以root用户运行的，为了能够操作kubectl，Jenkins可能需要有root权限。
系统配置：在某些特定的系统配置中，可能需要Jenkins以root用户运行以访问特定的系统资源或执行系统级别的操作。
NFS权限问题：在Kubernetes中部署Jenkins时，如果Jenkins容器以非root用户启动，而NFS服务器上的目录是以root用户启动的，可能会遇到权限问题。在这种情况下，可能需要将Jenkins的启动用户设置为root以解决权限问题。

总的来说，将Jenkins配置为以root用户启动是一个特定情况下的解决方案，通常不推荐这样做，因为它会增加安全风险。在大多数情况下，应该尽量避免以root用户运行Jenkins，而是通过配置适当的权限和使用sudoers文件来安全地授权Jenkins执行需要更高权限的操作。

在Jenkins中将JENKINS_USER设置为root通常不是一个推荐的做法，因为这会带来安全风险。但是，如果你确实需要这样做，以下是一些可能的方法来配置Jenkins以root用户运行：

对于Jenkins WAR文件运行方式：

直接使用命令行：
如果你通常是通过命令行启动Jenkins WAR文件，可以通过以下方式以root用户运行Jenkins：
```
sudo java -jar jenkins.war
```
这将使用root用户启动Jenkins。
设置环境变量：
你可以在启动Jenkins之前设置JENKINS_USER环境变量，但请注意，这通常不会改变Jenkins的运行用户，除非你的启动脚本或服务管理器支持这个变量：
```
export JENKINS_USER=root
java -jar jenkins.war
```

对于Jenkins服务运行方式（使用init脚本或systemd）：

修改init脚本：
如果你使用的是基于init的系统（如使用/etc/init.d/jenkins），你可以编辑init脚本，将Jenkins的启动命令更改为使用root用户。例如：
```
sudo nano /etc/init.d/jenkins
```
找到启动Jenkins的行，将其更改为：
```
sudo -u root java -jar /path/to/jenkins.war
```
然后重新启动Jenkins服务：
```
sudo service jenkins restart
```
修改systemd服务文件：
如果你使用的是基于systemd的系统，你可以编辑Jenkins的systemd服务文件：
```
sudo nano /etc/systemd/system/jenkins.service
```
找到ExecStart行，将其更改为：
```
ExecStart=/usr/bin/java -jar /path/to/jenkins.war
```
然后添加以下行来指定用户：
```
User=root
Group=root
```
保存并重新加载systemd配置：
```
sudo systemctl daemon-reload
sudo systemctl restart jenkins
```

注意事项：

安全性：再次强调，以root用户运行Jenkins会带来安全风险。确保你了解这些风险，并且这是你确实需要的。
权限管理：如果你需要Jenkins执行特定的需要高权限的操作，考虑使用sudo或su命令来限制权限，而不是将整个Jenkins服务以root用户运行。
文件权限：确保Jenkins的家目录和所有相关文件的权限设置正确，以便root用户可以访问。

在实际操作中，通常推荐的做法是创建一个具有必要权限的非root用户，并以该用户运行Jenkins，同时通过适当的权限管理策略来控制对系统资源的访问。

（可选）配置提升的Jenkins的插件的下载速度下载源

vim /var/lib/jenkins/hudson.model.UpdateCenter.xml

将下面的地址替换成国内下载源地址即可
在这里插入图片描述

或者在网页中配置:
插件管理里面的URL设置：

配置Jenkins的插件

在这里插入图片描述

Git插件

在Jenkins中使用Git，您需要安装和配置相关的Git插件。以下是详细步骤和推荐的插件：

1. 安装Git插件

步骤1： 登录到Jenkins仪表板，点击“管理Jenkins”。
步骤2： 选择“管理插件”。
步骤3： 在插件页面中，切换到“Available”标签页，在搜索框中输入“Git”。
步骤4： 找到“Git Plugin”，选择后点击“Install without restart”或“Download now and Install after restart”进行安装。

2. 推荐的Git相关插件

以下是一些与Git相关的Jenkins插件，它们可以帮助您更好地管理和集成Git仓库：

Git Plugin： 这是Jenkins最重要的插件之一，允许您将Git作为源代码管理工具集成到Jenkins中，支持从Git仓库拉取代码，并进行构建和测试。
GitHub Branch Source Plugin： 从一个或多个GitHub用户或组织创建基于存储库结构的新项目。
SSH Build Agents plugin： 提供通过SSH启动代理的方法。
Git Parameter： 允许在构建时选择Git参数，如分支或标签。
Maven Integration： 使得Jenkins能够很好地与Maven项目协作，支持Maven构建过程中的多种功能。

3. 手动下载并安装插件

如果您的Jenkins服务器无法连接外网，您需要手动下载插件：

步骤1： 访问Jenkins官网的插件下载页面，搜索插件名称，比如“Git”。
步骤2： 下载对应的插件版本，会得到.hpi文件。
步骤3： 在Jenkins插件管理页面（Manage Jenkins->Manage Plugins），选择高级设置页面，将下载的.hpi文件上传即可安装。

4. 配置Git

步骤1： 在Jenkins的主页上，点击“Manage Jenkins”，然后选择“Configure System”。
步骤2： 滚动到“Git”部分，在“Path to Git executable”字段中输入“git”。
步骤3： 在“Global Config user.name Value”和“Global Config user.email Value”字段中，填入您在Git仓库中注册的用户名和邮箱地址。

5. 配置项目使用Git

步骤1： 创建或编辑一个项目，在“Source Code Management”部分，选择“Git”。
步骤2： 在“Repository URL”字段中，填入您的Git仓库的HTTPS地址。
步骤3： 点击“Add”按钮，填入您的Git仓库的用户名和密码，以便Jenkins能够访问您的仓库。

通过以上步骤，您可以在Jenkins中详细使用Git，并结合相关的插件来提高您的工作效率。

GitLab插件

在Jenkins中使用GitLab，您需要安装和配置相关的GitLab插件。以下是详细步骤和推荐的插件：

1. 安装GitLab插件

步骤1： 打开Jenkins管理页面，通常是 http://<你的Jenkins服务器地址>:8080。
步骤2： 点击左侧菜单中的“系统管理”。
步骤3： 在“系统管理”页面中，点击“插件管理”。
步骤4： 在“插件管理”页面中，切换到“可选插件”标签页。
步骤5： 在搜索框中输入“GitLab Plugin”，找到该插件并勾选。
步骤6： 点击“直接安装”按钮，等待插件安装完成。

2. 推荐的GitLab相关插件

以下是一些与GitLab相关的Jenkins插件，它们可以帮助您更好地管理和集成GitLab仓库：

GitLab Plugin： 这款插件旨在无缝连接GitLab和Jenkins，实现代码提交时自动触发构建，并将构建状态反馈到GitLab平台。
Credentials Plugin： 用于管理签名证书，通常默认已经安装。
SSH Plugin： 这个插件使用SSH协议远程执行shell命令，方便与GitLab进行交互。

3. 配置Jenkins与GitLab的集成

步骤1： 在Jenkins管理页面中，点击左侧菜单中的“系统管理”。
步骤2： 在“系统管理”页面中，点击“系统配置”。
步骤3： 在“系统配置”页面中，找到“GitLab”部分。
步骤4： 输入你的GitLab服务器地址，例如 https://yourgitlab.server。
步骤5： 点击“添加”按钮，选择“GitLab API token”作为凭证类型。
步骤6： 在GitLab中创建一个API token，并将其粘贴到Jenkins的“API token”字段中。
步骤7： 点击“测试连接”按钮，确保Jenkins能够成功连接到GitLab。

4. 配置Jenkins作业

步骤1： 在Jenkins管理页面中，点击左侧菜单中的“新建任务”。
步骤2： 输入任务名称，选择“自由风格项目”，然后点击“确定”。
步骤3： 在任务配置页面中，找到“源码管理”部分，选择“Git”。
步骤4： 输入你的GitLab仓库URL，并配置相应的凭证（通常是SSH凭证）。
步骤5： 在“构建触发器”部分，勾选“GitLab”选项。
步骤6： 配置触发器规则，例如“Push events”或“Merge Request events”。
步骤7： 保存配置。

5. 配置GitLab Webhook

步骤1： 在GitLab中，进入你的项目页面。
步骤2： 点击左侧菜单中的“设置”，然后选择“Webhooks”。
步骤3： 输入Jenkins的Webhook URL，格式为 https://<你的Jenkins服务器地址>/project/<你的Jenkins任务名称>。
步骤4： 选择触发事件，例如“Push events”或“Merge Request events”。
步骤5： 点击“添加Webhook”。

通过以上步骤，您可以在Jenkins中详细使用GitLab，并结合相关的插件来提高您的工作效率。

在这里插入图片描述

Maven插件

在Jenkins中使用Maven进行项目管理和构建，您需要安装和配置相关的Maven插件。以下是详细步骤和推荐的插件：

1. 安装Maven插件

步骤1： 登录到Jenkins平台，点击“Manage Jenkins”进入管理页面。
步骤2： 在左侧导航栏中选择“Manage Plugins”，然后点击“Available”选项卡。
步骤3： 在搜索框中输入“Maven Integration”，找到Maven插件，点击安装。
步骤4： 弹出确认框后，点击“Install without restart”进行安装。
步骤5： 安装完成后，点击“Reload Configuration”重新加载Jenkins配置。

2. 推荐的Maven相关插件

以下是一些与Maven相关的Jenkins插件，它们可以帮助您更好地管理和集成Maven项目：

Maven Integration Plugin： 这个插件提供了对Maven项目的深度集成，包括自动解析POM文件、自动记录JUnit测试报告、自动创建项目依赖等。
Publish Over SSH Plugin： 这个插件允许您通过SSH将构建产物发布到远程服务器。

3. 配置Jenkins与Maven

步骤1： 在Jenkins管理页面中，点击“Configure System”。
步骤2： 滚动到“Maven”部分，点击“Add Maven”按钮。
步骤3： 取消选中“Install automatically”选项，添加名称和设置MAVEN_HOME的位置。
步骤4： 保存配置。

4. 配置Jenkins作业使用Maven

步骤1： 在Jenkins中创建或编辑一个项目，在“构建”部分，选择“Invoke top-level Maven targets”。
步骤2： 在“Goals”字段中输入您想要执行的Maven目标，如clean package（表示先清理项目，然后打包）。

5. 全局工具配置

步骤1： 在Jenkins管理页面中，点击“全局工具配置”。
步骤2： 在这里，您需要添加Maven的配置，包括Maven安装目录、设置MAVEN_OPTS环境变量等。

通过以上步骤，您可以在Jenkins中详细使用Maven，并结合相关的插件来提高您的工作效率。这些插件和配置将帮助您自动化构建、测试和部署Maven项目。

在这里插入图片描述

SSH插件

在Jenkins中使用SSH，您需要安装和配置相关的SSH插件。以下是详细步骤和推荐的插件：

1. 安装SSH插件

SSH Plugin： 这个插件允许Jenkins通过SSH执行远程命令或传输文件，对于在多个服务器之间进行任务协调、部署和维护工作非常有用。
- 进入Jenkins管理控制台，点击“Manage Jenkins”。
- 选择“Manage Plugins”。
- 在“Available”标签下搜索“SSH Plugin”。
- 勾选“SSH Plugin”并点击“Install without restart”进行安装。
- 安装完成后，可以选择立即重启Jenkins使插件生效，或稍后重启。
Publish Over SSH Plugin： 这个插件允许Jenkins通过SSH的方式远程连接服务器，并进行文件的传输和命令执行，特别适用于构建完成后将文件或构建产物传输到指定的远程服务器上。
- 在Jenkins插件管理中搜索“Publish Over SSH”即可进行安装。

2. 推荐的SSH相关插件

以下是一些与SSH相关的Jenkins插件，它们可以帮助您更好地管理和集成SSH功能：

SSH Build Agents plugin： 为Jenkins项目提供通过SSH启动代理的方法。
Publish Over SSH： 用于在构建完成后将文件或构建产物传输到指定的远程服务器上。

3. 配置SSH服务器

进入“Manage Jenkins” -> “Configure System”。
找到“SSH remote hosts”部分，点击“Add”按钮添加一个新的SSH服务器。
配置SSH服务器的详细信息：
- Name：为SSH服务器起一个名字，方便识别。
- Hostname：SSH服务器的主机名或IP地址。
- Port：SSH服务器的端口号，默认是22。
- Credentials：选择或添加SSH凭据（包括用户名和密码或私钥）。

4. 测试SSH连接

在配置完成后，可以点击“Test Configuration”按钮测试连接，确保Jenkins能够通过SSH连接到远程服务器。

5. 在Jenkins Job中使用SSH插件

进入需要使用SSH插件的Jenkins Job。
点击“Configure”进入Job的配置页面。
在“Build”部分，点击“Add build step”按钮。
选择“Send files or execute commands over SSH”。
配置SSH操作，包括选择之前配置的SSH服务器、传输文件的路径、远程目录等。

通过以上步骤，您可以在Jenkins中详细使用SSH，并结合相关的插件来提高您的工作效率。这些插件和配置将帮助您自动化构建、测试和部署过程中的远程操作。

在这里插入图片描述

Sonar插件

Jenkins的Sonar插件是指用于将SonarQube集成到Jenkins持续集成/持续部署（CI/CD）流程中的插件。SonarQube是一个开源的平台，用于持续检查代码质量，它能够检测代码中的错误、漏洞、代码异味（code smells）以及技术债务等。

什么是SonarQube

SonarQube通过对代码库进行静态代码分析来评估代码质量。它支持多种编程语言，并且可以集成到开发流程中，帮助开发团队提高代码质量、减少技术债务，并及早发现潜在的代码问题。

Jenkins的Sonar插件有什么用

代码质量分析：
- Jenkins的Sonar插件允许在构建过程中自动触发SonarQube的代码质量分析。
- 它将代码提交到SonarQube服务器进行分析，并生成详细的代码质量报告。
集成到CI/CD流程：
- 插件使得SonarQube可以无缝集成到Jenkins的CI/CD流程中，确保每次代码提交或合并请求（MR/PR）都会触发代码质量检查。
- 这有助于自动化代码审查过程，并在代码合并到主分支之前识别问题。
质量门禁（Quality Gates）：
- SonarQube的“质量门禁”功能允许设置代码质量的阈值。如果代码质量不满足预设的标准，构建会失败，这样可以阻止低质量的代码被合并。
- Jenkins的Sonar插件支持这些质量门禁，确保只有符合质量标准的代码才能通过。
历史趋势和比较：
- 插件可以帮助追踪代码质量的历史趋势，比较不同版本之间的代码质量变化。
- 这有助于团队理解代码质量的变化，并采取相应的改进措施。
问题追踪和修复：
- 通过Jenkins的Sonar插件，开发人员可以直接在Jenkins界面中查看SonarQube报告的问题。
- 开发人员可以更容易地定位问题，并在Jenkins中直接修复这些问题。
报告和通知：
- Jenkins可以配置为在SonarQube分析完成后发送通知，例如通过邮件或其他集成工具。
- 这有助于团队成员及时了解代码质量分析的结果。
自定义和扩展：
- Jenkins的Sonar插件支持自定义SonarQube分析参数，以适应特定的项目需求。
- 它还允许与其他Jenkins插件集成，以实现更复杂的构建和部署流程。

总的来说，Jenkins的Sonar插件是一个强大的工具，它将代码质量分析集成到自动化构建和部署流程中，帮助团队提高代码质量，减少技术债务，并确保软件的可靠性和安全性。

在Jenkins中集成SonarQube可以帮助自动化代码质量分析流程。以下是如何在Jenkins中详细使用SonarQube的步骤，以及需要下载的相关插件。

1. 安装SonarQube插件

在Jenkins中使用SonarQube，您需要安装以下插件：

SonarQube Scanner for Jenkins：这个插件允许Jenkins构建过程中调用SonarQube Scanner来分析代码质量。
SonarQube Quality Gates：这个插件可以在Jenkins中显示SonarQube的质量门限结果。

下载和安装插件的步骤：

在Jenkins仪表板中，点击“Manage Jenkins”。
选择“Manage Plugins”。
在“Available”标签页中搜索上述插件名称，勾选它们，然后点击“Install without restart”或“Download now and install after restart”进行安装。

2. 配置SonarQube服务器

在Jenkins仪表板中，点击“Manage Jenkins”。
选择“Configure System”。
找到“SonarQube servers”部分，点击“Add SonarQube”来添加一个新的SonarQube服务器。
输入您的SonarQube实例的名称、服务器URL、以及用于认证的凭证（Token或用户名和密码）。

3. 配置Jenkins项目使用SonarQube

在Jenkins中创建或编辑一个项目。
在项目配置页面中，找到“Build”部分，点击“Add build step”。
选择“Invoke SonarQube Scanner”或“Invoke SonarQube Scanner (experimental)”。
在配置中指定SonarQube服务器、项目Key、项目名称、源代码目录等信息。
您还可以指定其他SonarQube参数，如语言、数据库连接等。

4. 编写Jenkinsfile（可选）

如果您使用Jenkins Pipeline，可以在Jenkinsfile中添加SonarQube步骤：

pipeline {
    agent any
    stages {
        stage('SonarQube Analysis') {
            steps {
                withSonarQubeEnv('your-sonarqube-server-name') {
                    sh 'mvn clean verify sonar:sonar'
                }
            }
        }
    }
}

请确保替换'your-sonarqube-server-name'为您在Jenkins中配置的SonarQube服务器名称，并且您的项目是Maven项目。

5. 构建项目

保存项目配置并运行构建。
在构建过程中，Jenkins会调用SonarQube Scanner来分析代码。
构建完成后，您可以在Jenkins构建页面中查看SonarQube的分析结果，或者直接访问SonarQube仪表板查看详细的代码质量报告。

6. 配置质量门限（可选）

如果您安装了SonarQube Quality Gates插件，您可以在项目配置中设置质量门限，以确保只有当代码质量满足特定标准时，构建才会被认为是成功的。

通过以上步骤，您可以在Jenkins中详细使用SonarQube，并结合相关的插件来提高代码质量分析的自动化程度。

Pipeline插件

在Jenkins中使用Pipeline，您需要了解Pipeline的基本概念、如何创建Pipeline项目、编写Pipeline脚本，以及安装和使用相关的Pipeline插件。以下是详细步骤和推荐的插件：

1. 了解Pipeline的基本概念

Pipeline是Jenkins提供的工作流自动化工具，允许您定义整个构建、测试和部署流程为代码，通常使用一个名为Jenkinsfile的文本文件来描述这个流程。

2. 创建Pipeline项目

在Jenkins主页上点击“New Item”。
输入Pipeline的名称，选择“Pipeline”类型，然后点击“OK”。
点击“Finish”，一个Pipeline项目就生成了。

3. 编写Pipeline脚本

Pipeline脚本是用Groovy语言写的，您可以在Pipeline项目配置页面中编写Groovy脚本来定义您的流水线。例如，一个简单的Pipeline脚本可能包含以下几个阶段：

pipeline {
    agent any
    stages {
        stage('Build') {
            steps {
                echo 'Building...'
            }
        }
        stage('Test') {
            steps {
                echo 'Testing...'
            }
        }
        stage('Deploy') {
            steps {
                echo 'Deploying...'
            }
        }
    }
}

这个脚本定义了一个包含构建、测试和部署三个阶段的Pipeline。

4. 安装Pipeline相关插件

以下是一些与Pipeline相关的插件，它们可以帮助您更好地管理和集成Pipeline功能：

Pipeline Plugin：支持Pipeline的定义和执行。
Blue Ocean Plugin：提供现代化的用户界面，方便Pipeline的可视化管理。
Credentials Plugin：用于管理凭据，如SSH密钥、API令牌等。
Pipeline GitHub Plugin：用于与GitHub代码托管服务集成，包括拉取代码、创建Pull Request、发送状态通知等操作。
Pipeline Utility Steps插件：提供一组常用的Pipeline步骤，用于处理文件、文本、JSON等操作。
Pipeline Maven Integration插件：与Maven构建工具集成，提供了一组Pipeline步骤，用于执行Maven构建任务。
Pipeline NPM Integration插件：与Node.js和NPM集成，提供了一组Pipeline步骤，用于执行Node.js和NPM相关的操作。

5. 下载插件

进入Jenkins的管理界面，点击“Manage Jenkins”。
选择“Manage Plugins”。
在“Available”标签下搜索需要的插件，选择并安装。

通过以上步骤，您可以在Jenkins中详细使用Pipeline，并结合相关的插件来提高您的工作效率。这些插件和配置将帮助您自动化构建、测试和部署过程中的各个环节。

在这里插入图片描述

Jenkins存放插件的目录：

/var/lib/jenkins/plugins/

Jenkins支持多种类型的插件，以扩展其功能和适应不同的使用场景。以下是一些主要的插件类型及其用途：

代码管理插件：
- 支持集成不同的版本控制系统，如Git、Subversion等。
项目及视图插件：
- 允许用户使用目录管理项目，支持嵌套目录和视图创建，如Folders Plugin。
构建触发插件：
- 支持多种构建触发方式，包括周期性触发、远程触发、基于代码变更的触发等，如Gerrit Trigger、GitLab Hook、GitHub Integration等。
构建参数插件：
- 提供丰富的参数类型，支持参数间动态关联、多层级参数、隐藏参数等，如nodelabelparameter、Hidden Parameter等。
构建任务及环境插件：
- 提供构建前后清理工作空间、设置构建描述、构建名字等功能，如Workspace Cleanup、description setter等。
构建通知插件：
- 支持构建状态通知，包括邮件通知、Slack通知等，如Mailer、Slack Notification Plugin。
容器化Slave插件：
- 支持将Jenkins Slave节点容器化，如Docker Plugin、Kubernetes Plugin。
安全和权限插件：
- 提供细粒度的访问控制和用户认证，如Matrix Authorization Strategy Plugin、PAM Authentication plugin、LDAP Plugin等。
CI/CD Pipeline插件：
- 支持Pipeline的定义和执行，如Pipeline Plugin，包括Declarative Pipeline和Scripted Pipeline。
其他实用插件：
- 包括但不限于邮件扩展、HTTP请求、Xvfb（虚拟X服务器）、Job Generator、Job DSL Plugin等。

这些插件使得Jenkins能够适应各种不同的自动化需求，从代码管理到构建、测试、部署，再到通知和安全控制，Jenkins插件系统提供了强大的扩展能力。

通过本地文件安装插件

在这里插入图片描述
.hpi文件是Jenkins插件的安装包文件，它代表“Hudson Plugin Interface”，是Jenkins插件的分发格式。每个.hpi文件都是自包含的，包含了运行插件所需的所有代码、图像和其他资源。

.hpi文件与Jenkins插件的关系非常密切，因为它们是插件的安装包。当用户从Jenkins的更新中心下载插件或者手动上传插件时，插件就是以.hpi文件的形式存在的。

在Jenkins中，插件可以自动从更新中心下载，包括它们的依赖关系，这些插件被打包成.hpi文件。当插件通过Jenkins的Web UI安装时，.hpi文件会被重命名为.jpi扩展名，并且存储在JENKINS_HOME/plugins目录下。这种重命名是Jenkins在手动安装时将.hpi文件转换为.jpi文件的一部分，以确保在重启后上传的版本可以覆盖现有版本。

总的来说，.hpi文件是Jenkins插件的安装包，与Jenkins插件的使用和分发密切相关。

*三-pre、代码上线大致流程

GitLab中创建项目

提供给开发提交代码

创建分支

可以按照项目功能创建分支
可以按照开发人员的名字创建不同开发人员写的代码的分支
可以按照项目的版本创建分支

可以配置分支保护避免其他人随便访问修改

提交代码到对应的分支

提交审核工单是否将分支合并

从GitLab中的拉取对应的仓库版本代码

后端代码编译构建

使用工具(sonarqube)代码质量检测

灰度发布

在负载均衡器上摘除需要更新的机器

将代码推送到那个需要更新的机器的站点目录

绑定测试域名对代码进行功能等测试

如果测试没有问题就将该机器重新接入负载均衡器中

如果有问题那么回滚

三、Jenkins与GitLab仓库配合实现将Web应用代码自动化部署到Web服务器

三-1、基本流程

Jenkins是一个开源的自动化服务器，可以用于自动化各种任务，包括构建、测试和部署软件。GitLab是一个基于Web的Git仓库管理系统，提供代码库、代码审查、项目管理和CI/CD（持续集成/持续部署）等功能。Jenkins与GitLab配合实现自动化部署的基本流程如下：

1. 配置GitLab

首先，在GitLab上创建一个项目，并将您的Web应用代码推送到这个项目中。

2. Jenkins与GitLab集成

安装GitLab插件：在Jenkins中安装GitLab插件，以便Jenkins可以与GitLab集成。
配置GitLab服务器：在Jenkins的系统配置中，添加GitLab服务器的连接信息，包括GitLab的URL、访问凭证等。

3. 创建Jenkins项目

在Jenkins中创建一个新的项目，并配置以下内容：

源代码管理（SCM）：指定GitLab项目作为源代码管理工具，并输入项目的Git仓库地址。同时，配置相关的凭据，以便Jenkins可以拉取代码。
构建触发器：设置触发构建的条件，常见的有：
- 轮询SCM：Jenkins定时检查GitLab仓库中的变化。
- Webhooks：GitLab在代码推送后通过Webhook通知Jenkins触发构建。

注：这里的“Git仓库地址”可识别的前提是Jenkins机器的是提前安装了git命令且Jenkins机器登录用户的ssh-keygen生成的公钥是存储到Gitlab页面的ssh密钥配置中的
且Jenkins机器与gitLab仓库的机器之间需要进行如下的指纹验证EDSA：
在这里插入图片描述

4. 配置构建和部署

构建步骤：定义构建步骤，例如编译代码、运行测试等。
部署步骤：定义部署步骤，这可能包括：
- 使用SSH连接到部署服务器。
- 将构建好的应用文件（例如WAR、JAR包或静态文件）复制到部署服务器。
- 在部署服务器上执行部署脚本，如重启Web服务器或应用服务器。

这句话中的“构建”一词通常指的是在软件开发过程中，将源代码转换成可执行程序的过程。这个过程可能包括多个步骤，比如编译代码（将高级编程语言转换成机器语言）、链接（将编译后的代码与库文件合并成一个单一的可执行文件）、运行测试（确保代码按照预期工作）等。简而言之，“构建”就是将代码从原始形式转换成可以在计算机上运行的形式的一系列操作。

5. 配置Webhook

在GitLab项目设置中，找到Webhooks部分，并添加Jenkins的Webhook URL。这样，每当代码被推送到GitLab时，GitLab就会发送一个POST请求到Jenkins，触发一个新的构建。

6. 构建和部署

当代码被推送到GitLab仓库时，根据配置的触发器，Jenkins会自动开始构建过程。
Jenkins会从GitLab拉取最新的代码，执行构建步骤，如果构建成功，接着执行部署步骤。
部署步骤会将应用部署到Web服务器，并确保应用可以正常运行。

7. 监控和日志

Jenkins提供了构建历史和日志，方便监控构建和部署过程。
如果构建或部署失败，Jenkins会提供失败的详细信息，帮助开发者快速定位问题。

通过以上步骤，Jenkins与GitLab的集成可以实现代码的自动化构建和部署，提高开发效率，减少人为错误，并加快软件交付的速度。这种集成还支持持续集成和持续部署的实践，使得开发团队能够快速响应需求变化，持续改进软件产品。

三-2、能否单独使用GitLab实现上面的自动化部署到Web服务器

是的，GitLab本身提供了一个强大的CI/CD功能，允许您直接在GitLab中配置和实现自动化部署流程，而不需要依赖外部的CI/CD工具如Jenkins。GitLab CI/CD通过.gitlab-ci.yml文件来定义构建和部署的流程。以下是使用GitLab实现自动化部署的基本步骤：

1. 创建`.gitlab-ci.yml`文件

在您的GitLab项目的根目录下创建一个.gitlab-ci.yml文件，这个文件定义了CI/CD的管道（pipeline），包括各种阶段（stages），如build、test和deploy。

2. 定义构建和部署步骤

在.gitlab-ci.yml文件中定义构建和部署的步骤。例如：

stages:
  - build
  - deploy

build_job:
  stage: build
  script:
    - echo "Building the application..."
    - ./gradlew build # 假设您使用Gradle作为构建工具

deploy_job:
  stage: deploy
  script:
    - echo "Deploying the application..."
    - 'which rsync || (apt-get update -y && apt-get install rsync -y)'
    - rsync -avz --delete build/ deploy_user@deploy_server:/path/to/webserver_directory
  only:
    - master # 只在master分支上部署

3. 配置部署凭据

为了使GitLab能够访问您的Web服务器，您需要在GitLab项目的设置中配置部署凭据：

添加部署凭据：在项目的Settings > CI/CD > Variables中添加新的变量，例如DEPLOY_SERVER、DEPLOY_USER和DEPLOY_PATH，分别用于存储部署服务器的地址、用户名和目标路径。
SSH密钥：生成SSH密钥对，并在GitLab项目的Settings > Repository > SSH keys中添加公钥。确保私钥保存在安全的地方，GitLab CI/CD运行器将使用它来访问您的服务器。

4. 触发CI/CD管道

当您推送代码到GitLab仓库时，GitLab CI/CD会自动触发管道。您可以在项目的CI/CD > Pipelines中查看管道的运行状态。

5. 监控部署

GitLab提供了详细的管道和作业日志，您可以在CI/CD > Pipelines中查看每个部署作业的输出，以监控部署过程。

6. 处理部署失败

如果部署失败，GitLab会显示错误信息，您可以根据日志信息进行调试和修复。

使用GitLab CI/CD的好处是，您可以完全在GitLab中管理代码、构建和部署流程，无需额外的CI/CD服务器或工具。这简化了管理流程，并使得整个开发、构建和部署流程更加一体化。此外，GitLab CI/CD还支持环境、动态环境、手动部署批准等高级功能，以适应更复杂的部署需求。

三-3、Jenkins使用Shell脚本+参数化构建过程

*不使用“参数化构建传参给脚本”的脚本

例如：
在这里插入图片描述

Jenkins的参数化构建是什么及具体如何使用

在Jenkins中使用“参数化构建过程”以及配合“Build step”中的“执行shell”的过程可以分为以下几个步骤：

1. 启用参数化构建过程

首先，你需要在Jenkins中创建一个自由风格的项目。在项目的配置页面中，找到“General”部分，并勾选“参数化构建过程”选项。这样，你就可以为构建任务添加参数了。

2. 添加参数

在“参数化构建过程”选项被勾选后，你可以添加不同类型的参数，例如字符串参数、布尔参数、选择参数等。这些参数可以在构建过程中被引用，以实现不同的构建行为。

3. 在构建步骤中使用参数

在“构建”选项卡中，你可以添加任意数量的构建步骤。在构建步骤中，你可以使用特殊的变量来引用传递的参数。例如，如果你传递了一个名为“BRANCH”的参数，则可以使用${BRANCH}来引用该参数的值。
在这里插入图片描述

4. 执行shell构建步骤

在构建步骤中，你可以选择“Execute shell”选项来执行shell命令。在“Command”文本框中输入你想要在Linux终端执行的命令。你可以输入多个命令，每行一个。

5. 使用参数执行shell命令

在“Execute shell”步骤中，你可以直接使用之前定义的参数。例如，如果你有一个参数名为BRANCH，你可以在shell命令中使用${BRANCH}来动态地执行针对不同分支的构建操作。例如：

git checkout ${BRANCH}
git pull
mvn clean install

这样，每次构建时，你都可以输入不同的分支名称作为参数，Jenkins将执行相应的shell命令来构建指定的分支。

6. 保存并构建项目

完成配置后，保存你的项目。然后，在“构建”选项卡中点击“立即构建”，或者在“控制台”中输入build来触发构建。在构建过程中，Jenkins将显示传递的参数值，以便你进行调试和验证。

通过以上步骤，你可以灵活地使用Jenkins的参数化构建功能，结合“执行shell”步骤来实现自动化构建和部署的不同需求。

使用“参数化构建传参给脚本”的脚本

已知Jenkins从GitLab拉取的文件将保存到/root/.jenkins/workspace/deploy_webapp1目录下
这里的“deploy_webapp1”是当前Jenkins任务名
可以在.jenkins中创建一个scripts目录，将脚本文件放于这个目录中，
执行的脚本deploy_to_webservers.sh的示例代码:

#!/bin/bash
# Author: Lotus43
# Description: deploy the webapp to webservers

cd /root/.jenkins/workspace

zip -r webapp1.zip deploy_webapp1

staging_webserver_ip="172.16.1.7"
staging_webserver_pwd="1"

production_webserver_ip="172.16.1.8"
production_webserver_pwd="1"

case $ENVIRONMENT in
        "staging")
                sshpass -p ${staging_webserver_pwd} ssh-copy-id -i /root/.ssh/id_rsa.pub root@${staging_webserver_ip} -o StrictHostKeyChecking=no

                sshpass -p ${staging_webserver_pwd} rsync -avz webapp1.zip root@${staging_webserver_ip}:/opt/

                ssh ${staging_webserver_ip} "cd /opt/ && unzip webapp1.zip"
                ;;
        "production")
                sshpass -p ${production_webserver_pwd} ssh-copy-id -i /root/.ssh/id_rsa.pub root@${production_webserver_ip} -o StrictHostKeyChecking=no &>/dev/null

                sshpass -p ${production_webserver_pwd} rsync -avz webapp1.zip root@${production_webserver_ip}:/opt/ &> /dev/null

                ssh ${production_webserver_ip} "cd /opt/ && unzip webapp1.zip"
                ;;
esac

Jenkins"Build Steps"的配置页面示例：
那么任务开始时，参数化构建开启时将自动传给脚本一个参数（脚本中会调用这个参数）)
在这里插入图片描述

执行结果：
在这里插入图片描述
全部输出信息如下：

Started by user admin43
Running as SYSTEM
Building in workspace /root/.jenkins/workspace/deploy_webapp1
The recommended git tool is: NONE
No credentials specified
 > git rev-parse --resolve-git-dir /root/.jenkins/workspace/deploy_webapp1/.git # timeout=10
Fetching changes from the remote Git repository
 > git config remote.origin.url git@gitlab.lotus431.com:lotus43/webapp1.git # timeout=10
Fetching upstream changes from git@gitlab.lotus431.com:lotus43/webapp1.git
 > git --version # timeout=10
 > git --version # 'git version 1.8.3.1'
 > git fetch --tags --progress git@gitlab.lotus431.com:lotus43/webapp1.git +refs/heads/*:refs/remotes/origin/* # timeout=10
 > git rev-parse refs/remotes/origin/master^{commit} # timeout=10
Checking out Revision 62595d2fa4cefffed74f1cfdb4f1780bbb1f5aec (refs/remotes/origin/master)
 > git config core.sparsecheckout # timeout=10
 > git checkout -f 62595d2fa4cefffed74f1cfdb4f1780bbb1f5aec # timeout=10
Commit message: "删除 架构图.jpg"
 > git rev-list --no-walk 62595d2fa4cefffed74f1cfdb4f1780bbb1f5aec # timeout=10
[deploy_webapp1] $ /bin/sh -xe /tmp/jenkins791106232308274759.sh
+ echo 'Hello! We will start this deploy task .....'
Hello! We will start this deploy task .....
+ echo -------------
-------------
[deploy_webapp1] $ /bin/sh -xe /tmp/jenkins17051000056982322828.sh
+ echo 调用参数化构建的字符串参数BRANCH:
调用参数化构建的字符串参数BRANCH:
+ echo BRANCH值为：
BRANCH值为：
+ echo master
master
[deploy_webapp1] $ /bin/sh -xe /tmp/jenkins12506934337776420409.sh
+ echo 调用参数化构建的布尔参数:RUN_TESTS：
调用参数化构建的布尔参数:RUN_TESTS：
+ '[' false = true ']'
+ echo -------------
-------------
[deploy_webapp1] $ /bin/sh -xe /tmp/jenkins4206056723784285640.sh
+ echo 调用参数化构建的选项参数:ENVIRONMENT：
调用参数化构建的选项参数:ENVIRONMENT：
+ echo 'Deploying to production environment...'
Deploying to production environment...
+ sh /root/.jenkins/shell_scripts/deploy_to_webserver.sh
updating: deploy_webapp1/ (stored 0%)
updating: deploy_webapp1/.git/ (stored 0%)
updating: deploy_webapp1/.git/refs/ (stored 0%)
updating: deploy_webapp1/.git/refs/heads/ (stored 0%)
updating: deploy_webapp1/.git/refs/tags/ (stored 0%)
updating: deploy_webapp1/.git/refs/remotes/ (stored 0%)
updating: deploy_webapp1/.git/refs/remotes/origin/ (stored 0%)
updating: deploy_webapp1/.git/refs/remotes/origin/master (stored 0%)
updating: deploy_webapp1/.git/branches/ (stored 0%)
updating: deploy_webapp1/.git/description (deflated 14%)
updating: deploy_webapp1/.git/hooks/ (stored 0%)
updating: deploy_webapp1/.git/hooks/applypatch-msg.sample (deflated 41%)
updating: deploy_webapp1/.git/hooks/commit-msg.sample (deflated 44%)
updating: deploy_webapp1/.git/hooks/post-update.sample (deflated 27%)
updating: deploy_webapp1/.git/hooks/pre-applypatch.sample (deflated 36%)
updating: deploy_webapp1/.git/hooks/pre-commit.sample (deflated 46%)
updating: deploy_webapp1/.git/hooks/pre-push.sample (deflated 50%)
updating: deploy_webapp1/.git/hooks/pre-rebase.sample (deflated 59%)
updating: deploy_webapp1/.git/hooks/prepare-commit-msg.sample (deflated 46%)
updating: deploy_webapp1/.git/hooks/update.sample (deflated 68%)
updating: deploy_webapp1/.git/info/ (stored 0%)
updating: deploy_webapp1/.git/info/exclude (deflated 28%)
updating: deploy_webapp1/.git/HEAD (stored 0%)
updating: deploy_webapp1/.git/config (deflated 27%)
updating: deploy_webapp1/.git/objects/ (stored 0%)
updating: deploy_webapp1/.git/objects/pack/ (stored 0%)
updating: deploy_webapp1/.git/objects/info/ (stored 0%)
updating: deploy_webapp1/.git/objects/25/ (stored 0%)
updating: deploy_webapp1/.git/objects/25/23d803589acf81f7971e4653080198ed2c69eb (stored 0%)
updating: deploy_webapp1/.git/objects/80/ (stored 0%)
updating: deploy_webapp1/.git/objects/80/7ad60ea01576889465d9e503c2ff2d5a02faa7 (stored 0%)
updating: deploy_webapp1/.git/objects/e6/ (stored 0%)
updating: deploy_webapp1/.git/objects/e6/9de29bb2d1d6434b8b29ae775ad8c2e48c5391 (stored 0%)
updating: deploy_webapp1/.git/objects/91/ (stored 0%)
updating: deploy_webapp1/.git/objects/91/d72eaca1c51cacba2ccba92fa6e55104e54985 (stored 0%)
updating: deploy_webapp1/.git/objects/c9/ (stored 0%)
updating: deploy_webapp1/.git/objects/c9/ecaf3c5f42fec675c8ec4d5faecf0e5b564868 (stored 0%)
updating: deploy_webapp1/.git/objects/e3/ (stored 0%)
updating: deploy_webapp1/.git/objects/e3/f48c880250ddf3364a33ddce91a079808ab029 (stored 0%)
updating: deploy_webapp1/.git/FETCH_HEAD (deflated 10%)
updating: deploy_webapp1/.git/logs/ (stored 0%)
updating: deploy_webapp1/.git/logs/refs/ (stored 0%)
updating: deploy_webapp1/.git/logs/refs/remotes/ (stored 0%)
updating: deploy_webapp1/.git/logs/refs/remotes/origin/ (stored 0%)
updating: deploy_webapp1/.git/logs/refs/remotes/origin/master (deflated 74%)
updating: deploy_webapp1/.git/logs/HEAD (deflated 76%)
updating: deploy_webapp1/.git/index (deflated 39%)
updating: deploy_webapp1/README.md (stored 0%)
updating: deploy_webapp1/file1.txt (stored 0%)
updating: deploy_webapp1/upload_file_dir/ (stored 0%)
updating: deploy_webapp1/upload_file_dir/upload_file_name (deflated 10%)
updating: deploy_webapp1/.git/objects/9b/ (stored 0%)
updating: deploy_webapp1/.git/objects/9b/0419c030c7c5c70c19aaf4b628f2c78f5282fc (stored 0%)
updating: deploy_webapp1/.git/objects/24/ (stored 0%)
updating: deploy_webapp1/.git/objects/24/791ab6d1409defca7799fd253417a5090edcf3 (stored 0%)
updating: deploy_webapp1/.git/objects/04/ (stored 0%)
updating: deploy_webapp1/.git/objects/04/9452ba5ba6baddc75d0f7ca60d78c25e36f77e (deflated 0%)
updating: deploy_webapp1/.git/objects/1e/ (stored 0%)
updating: deploy_webapp1/.git/objects/1e/10f38e2d61bb49f431e90273ac60cfd9502383 (stored 0%)
updating: deploy_webapp1/.git/objects/9f/ (stored 0%)
updating: deploy_webapp1/.git/objects/9f/52965ff75b37798079c096c717129a4482d2e7 (stored 0%)
updating: deploy_webapp1/.git/objects/62/ (stored 0%)
updating: deploy_webapp1/.git/objects/62/595d2fa4cefffed74f1cfdb4f1780bbb1f5aec (stored 0%)
Archive:  webapp1.zip
   creating: deploy_webapp1/
   creating: deploy_webapp1/.git/
   creating: deploy_webapp1/.git/refs/
   creating: deploy_webapp1/.git/refs/heads/
   creating: deploy_webapp1/.git/refs/tags/
   creating: deploy_webapp1/.git/refs/remotes/
   creating: deploy_webapp1/.git/refs/remotes/origin/
 extracting: deploy_webapp1/.git/refs/remotes/origin/master  
   creating: deploy_webapp1/.git/branches/
  inflating: deploy_webapp1/.git/description  
   creating: deploy_webapp1/.git/hooks/
  inflating: deploy_webapp1/.git/hooks/applypatch-msg.sample  
  inflating: deploy_webapp1/.git/hooks/commit-msg.sample  
  inflating: deploy_webapp1/.git/hooks/post-update.sample  
  inflating: deploy_webapp1/.git/hooks/pre-applypatch.sample  
  inflating: deploy_webapp1/.git/hooks/pre-commit.sample  
  inflating: deploy_webapp1/.git/hooks/pre-push.sample  
  inflating: deploy_webapp1/.git/hooks/pre-rebase.sample  
  inflating: deploy_webapp1/.git/hooks/prepare-commit-msg.sample  
  inflating: deploy_webapp1/.git/hooks/update.sample  
   creating: deploy_webapp1/.git/info/
  inflating: deploy_webapp1/.git/info/exclude  
 extracting: deploy_webapp1/.git/HEAD  
  inflating: deploy_webapp1/.git/config  
   creating: deploy_webapp1/.git/objects/
   creating: deploy_webapp1/.git/objects/pack/
   creating: deploy_webapp1/.git/objects/info/
   creating: deploy_webapp1/.git/objects/25/
 extracting: deploy_webapp1/.git/objects/25/23d803589acf81f7971e4653080198ed2c69eb  
   creating: deploy_webapp1/.git/objects/80/
 extracting: deploy_webapp1/.git/objects/80/7ad60ea01576889465d9e503c2ff2d5a02faa7  
   creating: deploy_webapp1/.git/objects/e6/
 extracting: deploy_webapp1/.git/objects/e6/9de29bb2d1d6434b8b29ae775ad8c2e48c5391  
   creating: deploy_webapp1/.git/objects/91/
 extracting: deploy_webapp1/.git/objects/91/d72eaca1c51cacba2ccba92fa6e55104e54985  
   creating: deploy_webapp1/.git/objects/c9/
 extracting: deploy_webapp1/.git/objects/c9/ecaf3c5f42fec675c8ec4d5faecf0e5b564868  
   creating: deploy_webapp1/.git/objects/e3/
 extracting: deploy_webapp1/.git/objects/e3/f48c880250ddf3364a33ddce91a079808ab029  
  inflating: deploy_webapp1/.git/FETCH_HEAD  
   creating: deploy_webapp1/.git/logs/
   creating: deploy_webapp1/.git/logs/refs/
   creating: deploy_webapp1/.git/logs/refs/remotes/
   creating: deploy_webapp1/.git/logs/refs/remotes/origin/
  inflating: deploy_webapp1/.git/logs/refs/remotes/origin/master  
  inflating: deploy_webapp1/.git/logs/HEAD  
  inflating: deploy_webapp1/.git/index  
 extracting: deploy_webapp1/README.md  
 extracting: deploy_webapp1/file1.txt  
  inflating: deploy_webapp1/进程管理2_to_learn.md  
   creating: deploy_webapp1/upload_file/
  inflating: deploy_webapp1/upload_file/dir1  
   creating: deploy_webapp1/upload_file_dir/
  inflating: deploy_webapp1/upload_file_dir/upload_file_name  
   creating: deploy_webapp1/.git/objects/9b/
 extracting: deploy_webapp1/.git/objects/9b/0419c030c7c5c70c19aaf4b628f2c78f5282fc  
   creating: deploy_webapp1/.git/objects/24/
 extracting: deploy_webapp1/.git/objects/24/791ab6d1409defca7799fd253417a5090edcf3  
   creating: deploy_webapp1/.git/objects/04/
  inflating: deploy_webapp1/.git/objects/04/9452ba5ba6baddc75d0f7ca60d78c25e36f77e  
  inflating: deploy_webapp1/架构图.jpg  
   creating: deploy_webapp1/.git/objects/1e/
 extracting: deploy_webapp1/.git/objects/1e/10f38e2d61bb49f431e90273ac60cfd9502383  
   creating: deploy_webapp1/.git/objects/9f/
 extracting: deploy_webapp1/.git/objects/9f/52965ff75b37798079c096c717129a4482d2e7  
   creating: deploy_webapp1/.git/objects/62/
 extracting: deploy_webapp1/.git/objects/62/595d2fa4cefffed74f1cfdb4f1780bbb1f5aec  
+ echo -------------
-------------
[deploy_webapp1] $ /bin/sh -xe /tmp/jenkins18322170272385628415.sh
+ echo 调用参数化构建的密码参数:DB_PASSWORD：
调用参数化构建的密码参数:DB_PASSWORD：
+ echo 密码参数DB_PASSWORD的值为：4439
密码参数DB_PASSWORD的值为：4439
+ echo -------------
-------------
Sending e-mails to: 2048935747@qq.com
Finished: SUCCESS

三-4、Jenkins使用WebHook自动触发构建

什么是Jenkins的WebHook及其实现的基本原理

Jenkins的Webhook是一种轻量级的事件通知机制，允许外部系统通过HTTP请求触发Jenkins的构建流程。以下是Webhook的基本原理和配置方法：

Webhook的基本原理

Webhook基于HTTP回调机制，当外部系统（如Git代码仓库）发生特定事件时（例如代码提交），它会向Jenkins发送一个HTTP请求。Jenkins接收到请求后，会根据预定义的规则触发相应的构建流程。这种方式不需要客户端不断轮询服务端的状态，而是服务端在事件发生时直接将数据发送到客户端，节省了系统资源并保证了数据的实时性。

Jenkins Webhook配置步骤

安装必要的插件：确保Jenkins中已经安装了Git插件或其他相关插件，以便支持Git仓库的操作。
创建或配置Job：在Jenkins中创建一个新的Job或配置现有的Job。在Job的配置页面中，找到源代码管理部分，选择Git作为代码仓库类型，并填写仓库地址。
配置构建触发器：在Job的配置页面中，找到构建触发器部分，选择Poll SCM并设置轮询频率，这将让Jenkins定期检查Git仓库是否有新的提交，并触发构建。
获取Webhook URL：在Jenkins项目配置页面的左侧菜单中，选择“配置”。然后在构建触发器部分，找到Webhook URL并复制它。这个URL将用于在Git仓库中配置Webhook。
在Git仓库中设置Webhook：
- 转到Git仓库的设置页面。
- 点击“Webhooks”或“Hooks”选项。
- 点击“Add webhook”按钮。
- 在“Payload URL”字段中，填写Jenkins服务器的URL，通常格式为http://<jenkins_url>/generic-webhook-trigger/invoke?token=<your_token>，其中<your_token>是Jenkins中为该项目设置的认证Token。
- 选择触发Webhook的事件，例如“Just the push event”或其他需要的事件。
- 保存Webhook配置。

通过以上步骤，当Git仓库发生配置的事件时，Git仓库服务器会向Jenkins发送一个HTTP请求，Jenkins接收到请求后，根据预设的规则触发相应的构建任务，实现自动化构建和部署。

设置Git仓库的Webhook具体步骤会根据你使用的Git服务提供商（如GitHub、GitLab、Bitbucket等）有所不同，但大体流程是类似的。以下是一些常见Git服务提供商设置Webhook的步骤：

GitHub

登录GitHub账户：访问GitHub并登录你的账户。
选择仓库：点击右上角的“+”号，选择“Your repositories”（你的仓库），然后点击“New”创建新仓库或选择一个已有的仓库。
进入设置：在仓库页面，点击“Settings”（设置）选项。
找到Webhooks部分：在设置页面的左侧菜单中，点击“Webhooks”（Webhooks）。
添加Webhook：点击“Add webhook”按钮。
配置Webhook：
- Payload URL：输入Jenkins服务器的Webhook URL，通常是http://<jenkins_url>/github-webhook/。
- Content type：选择application/json。
- Which events would you like to trigger this webhook?：选择触发Webhook的事件，如Just the push event。
- Active：确保勾选此选项以激活Webhook。
添加：点击“Add webhook”按钮完成添加。

GitLab

登录GitLab账户：访问GitLab并登录你的账户。
选择项目：点击“Projects”（项目），然后选择一个项目。
进入设置：在项目页面，点击“Settings”（设置）选项，然后点击“Webhooks”（Webhooks）。
添加Webhook：点击“Add webhook”按钮。
配置Webhook：
- URL：输入Jenkins服务器的Webhook URL，通常是http://<jenkins_url>/gitlab-webhook/。
- Trigger：选择触发Webhook的事件，如Push events。
- Enable SSL verification：根据需要选择是否启用SSL验证。
添加：点击“Add webhook”按钮完成添加。

Bitbucket

登录Bitbucket账户：访问Bitbucket并登录你的账户。
选择仓库：点击“Repositories”（仓库），然后选择一个仓库。
进入设置：在仓库页面，点击“Settings”（设置）选项，然后点击“Webhooks”（Webhooks）。
添加Webhook：点击“Webhooks”旁边的“Add webhook”按钮。
配置Webhook：
- Title：给Webhook一个标题。
- URL：输入Jenkins服务器的Webhook URL，通常是http://<jenkins_url>/bitbucket-webhook/。
- Status：选择“Active”以激活Webhook。
- Events：选择触发Webhook的事件，如Repository push。
添加：点击“Save”按钮完成添加。

在配置Webhook时，确保Jenkins服务器的URL是正确的，并且Jenkins服务器能够接收来自Git服务提供商的HTTP请求。如果Jenkins服务器在私有网络中，你可能需要配置防火墙规则或使用反向代理来允许外部请求。此外，如果你的Jenkins服务器使用HTTPS，确保在URL中使用https://而不是http://。

在这里插入图片描述

Jenkins需要生成一个token、为什么要配置token

在Jenkins Webhook配置中设置“Secret Token”主要是出于安全性的考虑，它有以下几个用途：

验证请求的来源：Secret Token是一种安全措施，用于验证发送到Jenkins的Webhook请求是否来自一个可信的源。当GitLab（或其他Git服务提供商）触发Webhook时，它会将这个Token包含在HTTP请求中。Jenkins会检查这个Token是否与预期的值匹配，以确保请求不是由未授权的源发起的。
防止CSRF攻击：跨站请求伪造（CSRF）是一种攻击方式，攻击者诱使已登录的用户无意中执行非预期的操作。通过设置Secret Token，Jenkins可以防止这种攻击，因为攻击者很难获取到这个Token，从而无法伪造合法的Webhook请求。
增强安全性：在Jenkins中配置Secret Token，可以增加一层安全保护。即使有人知道了Webhook的URL，如果没有正确的Token，他们也无法触发Jenkins的构建。

Secret Token与监控GitLab仓库是相关的，因为在GitLab中配置Webhook时需要使用到这个Token。具体步骤如下：

在Jenkins中生成Token：在Jenkins项目的配置页面中，你可以点击“Advanced”按钮，然后点击“Generate”来生成一个Secret Token。
在GitLab中配置Webhook：将Jenkins生成的Secret Token复制到GitLab项目的Webhook配置中。这样，每当GitLab检测到代码提交时，它会向Jenkins发送一个包含这个Token的HTTP请求。
验证Token：Jenkins接收到来自GitLab的Webhook请求后，会验证请求中的Token是否与Jenkins中配置的Token一致。如果一致，Jenkins就会触发相应的构建任务。

通过这种方式，Secret Token确保了只有来自GitLab的合法请求才能触发Jenkins的构建，从而保护了Jenkins构建过程的安全性。

在Jenkins和GitLab的Webhook配置中设置“Secret Token”主要是为了验证请求的来源和增强安全性。以下是关于“Secret Token”的作用和是否需要经常更新的说明：

作用：
- 验证请求来源：Secret Token用于验证发送到Jenkins的Webhook请求是否来自一个可信的源，比如GitLab。当GitLab触发Webhook时，它会将这个Token包含在HTTP请求中。Jenkins会检查这个Token是否与预期的值匹配，以确保请求不是由未授权的源发起的。
- 防止CSRF攻击：Secret Token有助于防止跨站请求伪造（CSRF）攻击，因为攻击者很难获取到这个Token，从而无法伪造合法的Webhook请求。
- 增强安全性：配置Secret Token可以增加一层安全保护。即使有人知道了Webhook的URL，如果没有正确的Token，他们也无法触发Jenkins的构建。
是否需要经常更新：
- 通常，Secret Token不需要经常更新。它是一个一次性设置的安全措施，用于确保Webhook的安全性。除非有特定的安全需求或在Token泄露的情况下，否则没有必要频繁更改Secret Token。
- 如果你认为Secret Token不再安全，比如可能被泄露，那么应该立即更新它以保护系统的安全性。
- 在实际操作中，只有在需要提高安全性或者更换安全策略时，才需要更新Secret Token。

综上所述，Secret Token是Jenkins和GitLab Webhook配置中的一个重要安全特性，用于验证请求的合法性并防止未授权的访问。它不需要经常更新，除非出于安全考虑或Token泄露的情况。

在这里插入图片描述

GitLab的WebHook和token的配合设置

Webhook请求访问Gitlab本地网络错误问题：

在这里插入图片描述

解决办法：

在这里插入图片描述

测试GitLab的仓库改变后是否Jenkins将自动触发部署任务

在这里插入图片描述

四、Jenkins使用Maven插件创建构建、部署Maven项目的任务

——部署Maven项目到Web服务器
在这里插入图片描述

四-1、Maven的介绍

在这里插入图片描述

Maven是什么

Maven是一个项目管理和构建自动化工具，主要服务于基于Java的项目管理和构建。它使用一个名为POM（Project Object Model，项目对象模型）的XML文件来描述项目的构建过程、依赖关系、编译配置等。Maven的核心功能包括依赖管理、项目构建、文档生成和代码质量检查等。

Maven的用途

依赖管理：自动处理项目依赖，解决依赖冲突，无需手动下载和安装JAR文件。
项目构建：标准化构建过程，可以快速编译、测试、打包和部署项目。
项目管理：提供清晰的项目结构和生命周期管理。
代码质量：集成代码质量检查工具，如Checkstyle、PMD等。
文档生成：自动生成项目文档，如JavaDoc和Site。
项目报告：生成项目报告，如代码覆盖率报告。
继承和聚合：支持多模块项目构建，可以继承和聚合子模块的配置。

具体如何使用Maven

1. 安装Maven

下载Maven：从Apache Maven官方网站下载Maven。
解压并配置环境变量：将下载的Maven压缩包解压到一个目录，并设置环境变量M2_HOME指向该目录，将%M2_HOME%\bin添加到系统路径变量PATH中。

安装Maven二进制包并配置环境变量：
在这里插入图片描述

2. 配置Maven

编辑settings.xml文件：该文件位于M2_HOME/conf目录下，可以配置本地仓库位置、代理设置、镜像服务器等。

3. 创建Maven项目

使用IDE（如IntelliJ IDEA、Eclipse）创建Maven项目，IDE会帮助生成基本的POM文件。
或者，手动创建一个包含pom.xml文件的目录结构，pom.xml文件定义了项目的构建信息和依赖。

4. 编写POM文件

<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>com.example</groupId>
    <artifactId>demo-project</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
</project>

5. 使用Maven命令

在命令行中，进入项目根目录，使用以下Maven命令：

编译项目：mvn compile
运行测试：mvn test
打包项目：mvn package（会根据POM文件中的配置生成JAR或WAR文件）
安装项目到本地仓库：mvn install
部署项目到远程仓库：mvn deploy
运行项目：对于Web应用或其他可执行项目，可以使用mvn exec:java或其他插件来运行。

6. Maven生命周期

Maven有一系列的生命周期阶段，如clean、compile、test、package、verify、install和deploy。这些阶段可以组合成几个常用的生命周期，如clean、default（包含compile、test、package）、site等。

通过这些步骤，你可以开始使用Maven来管理Java项目的构建和依赖。Maven的强大之处在于其丰富的插件生态系统和约定大于配置的理念，这使得项目构建和管理变得更加标准化和自动化。

四-2、*Web配置Tomcat

yum install tomcat -y

touch /var/lib/tomcat/webapps/ROOT/index.jsp

echo "Hello,这是一个基于Tomcat运行的页面" >> /var/lib/tomcat/webapps/ROOT/index.jsp

CentOS7安装Maven和JRE版本的兼容性

在CentOS 7系统中安装Maven和配置JRE时，考虑版本兼容性是非常重要的。以下是一些关键点：

JDK版本要求：
- 根据搜索结果，CentOS 7系统推荐使用JDK 1.8版本。这是因为JDK 1.8是一个长期支持（LTS）版本，提供了稳定性和安全性更新。
- 有些项目可能不支持更高版本的JDK，因此在安装JDK时需要根据项目需求选择合适的版本。
Maven版本要求：
- 搜索结果中提到，Maven的版本对JDK的版本兼容性有所不同，一般越是高版本的Maven对JDK的兼容性越好。例如，Maven 3.9.0版本对JDK 17的兼容性较好。
- 对于CentOS 7，Maven 3.6.3是一个常用的版本，并且与JDK 1.8兼容良好。但是，如果项目需要使用JDK 17或更高版本，可能需要选择更高版本的Maven，如Maven 3.8.3。
Maven和JRE兼容性：
- Maven本身是一个Java应用程序，因此需要JRE（Java运行环境）来运行。Maven的任何版本都应该与JDK 1.8的JRE兼容，因为JDK 1.8包含了Maven运行所需的JRE。
- 在配置环境变量时，需要确保JAVA_HOME和JRE_HOME指向正确的JDK安装路径，并且PATH变量包含JAVA_HOME/bin和JRE_HOME/bin，以便Maven可以使用JDK的命令行工具。
安装和配置步骤：
- 首先，确保系统已更新所有软件包，使用yum update命令。
- 下载并安装JDK 1.8，配置环境变量JAVA_HOME和JRE_HOME。
- 下载Maven，解压到指定目录，并配置MAVEN_HOME环境变量。
- 配置Maven的settings.xml文件，指定国内镜像以加速依赖下载。

总结来说，CentOS 7上安装Maven和JRE时，需要确保JDK和Maven的版本相互兼容，并且正确配置环境变量以确保Maven可以正常运行。JDK 1.8是一个广泛支持的版本，而Maven的最新版本可以提供更好的兼容性和性能。

在CentOS 7上安装、配置和启动Tomcat涉及几个步骤。以下是详细指南：

1. 安装Tomcat

步骤1：添加Tomcat仓库

首先，您需要添加Tomcat的YUM仓库。创建一个名为tomcat的新repo文件：

sudo vi /etc/yum.repos.d/tomcat.repo

在该文件中添加以下内容：

[tomcat]
name=Apache Tomcat Repository
baseurl=http://repo.maven.org/maven2/org/apache/tomcat/tomcat/9.0.57/bin/distribution
enabled=1
gpgcheck=0

请根据需要更改baseurl以指向正确的Tomcat版本。上面的URL是Tomcat 9.0.57版本的URL。

步骤2：安装Tomcat

使用YUM安装Tomcat：

sudo yum install tomcat

步骤3：验证安装

检查Tomcat是否已正确安装：

rpm -qa | grep tomcat

您应该看到列出的Tomcat包。

2. 配置Tomcat

步骤1：配置环境变量

编辑/etc/profile或~/.bash_profile文件，添加以下内容以设置CATALINA_HOME和更新PATH：

export CATALINA_HOME=/usr/share/tomcat
export PATH=$PATH:$CATALINA_HOME/bin

保存文件并重新加载配置：

source /etc/profile

或者如果您使用的是.bash_profile：

source ~/.bash_profile

步骤2：配置`server.xml`

Tomcat的配置文件server.xml位于$CATALINA_HOME/conf目录下。您可以根据需要编辑此文件，例如更改端口号、添加上下文路径等。

例如，要更改默认的HTTP端口从8080到8081：

<Connector port="8081" protocol="HTTP/1.1"
           connectionTimeout="20000"
           redirectPort="8443" />

步骤3：配置用户

如果您需要配置Tomcat管理界面的访问权限，编辑$CATALINA_HOME/conf/tomcat-users.xml文件，并添加一个用户：

<tomcat-users>
  <role rolename="manager-gui"/>
  <user username="admin" password="password" roles="manager-gui"/>
</tomcat-users>

3. 启动Tomcat

步骤1：启动服务

使用systemd启动Tomcat服务：

sudo systemctl start tomcat

步骤2：设置开机启动

如果您希望Tomcat在系统启动时自动启动，可以使用以下命令：

sudo systemctl enable tomcat

步骤3：检查服务状态

检查Tomcat服务的状态以确保它正在运行：

sudo systemctl status tomcat

4. 访问Tomcat

在浏览器中输入http://your_server_ip:8081（或者您配置的其他端口），您应该能够看到Tomcat的默认欢迎页面。

5. 部署应用

将您的WAR文件放置在$CATALINA_HOME/webapps目录下，Tomcat会自动解压并部署应用。

以上是在CentOS 7上安装、配置和启动Tomcat的详细步骤。根据您的具体需求，您可能需要进行额外的配置和优化。

/usr/share/tomcat/webapps/ROOT和/var/lib/tomcat/webapps/ROOT的区别

在使用 yum install tomcat 安装Tomcat后，/var/lib/tomcat/webapps/ROOT 和 /usr/share/tomcat/webapps/ROOT 这两个目录在Tomcat中扮演着不同的角色，它们的主要区别如下：

目录结构和用途：
- /usr/share/tomcat/webapps/ 是Tomcat的默认Web应用程序部署目录。当你将一个Web应用程序（通常是WAR文件）放置在这个目录下时，Tomcat会自动解压缩并部署这个应用程序。这个目录包含了所有的Web应用程序，可以是静态的HTML页面，也可以是动态的Web应用程序。
- /usr/share/tomcat/webapps/ROOT 是Tomcat的默认Web应用程序的根目录。当你访问Tomcat服务器而没有指定具体的Web应用程序名称时，Tomcat会自动将请求映射到ROOT目录下的文件。这个目录通常包含一个欢迎页面，当访问Tomcat服务器的根URL（例如 http://localhost:8080/）时，Tomcat会默认加载ROOT目录下的文件作为默认的主页。
访问路径：
- 将Web应用程序部署到webapps/目录下时，需要通过访问具体的应用程序名称来访问，例如 http://localhost:8080/myapp。
- 将Web应用程序部署到webapps/ROOT/目录下时，可以直接通过根URL来访问应用程序，例如 http://localhost:8080/。
项目部署和访问：
- 如果你将Web应用程序的WAR文件或解压后的文件夹放在webapps/目录下，Tomcat会在启动时自动解压和部署这些应用程序。
- 如果你将Web应用程序的文件直接放在ROOT目录下，Tomcat会将这些文件作为默认的Web应用程序来运行，这样在访问Tomcat的根URL时，就可以直接访问这些文件，而不需要指定应用程序的名称。
符号链接：
- 在使用yum安装Tomcat后，Tomcat相关的目录通常会通过符号链接到/usr/share/tomcat目录，包括webapps等，这使得配置和管理更加方便。
- /var/lib/tomcat/webapps实际上是/usr/share/tomcat/webapps的符号链接，这意味着它们指向同一个物理位置。

总结来说，/var/lib/tomcat/webapps/ROOT和/usr/share/tomcat/webapps/ROOT在物理上是同一个位置，它们都是Tomcat中用于存放默认Web应用程序的目录。不同之处在于它们的访问路径和部署方式，以及它们在Tomcat中的作用。webapps/目录用于部署所有Web应用程序，而ROOT目录用于存放默认的主页和静态资源文件，可以直接通过根URL访问。

Tomcat的webapps目录和webapps下的ROOT目录的区别以及Tomcat的自动部署机制

在CentOS7中使用yum install tomcat安装Tomcat后，将.war文件放置于/usr/share/tomcat/webapps/ROOT目录下，然后执行systemctl start tomcat启动Tomcat服务，/usr/share/tomcat/webapps/ROOT目录中没有生成对应xxx目录的原因可能如下：

Tomcat的自动部署机制：通常情况下，当你将.war文件放置在webapps目录下时，Tomcat会在启动时自动解压这些.war文件，并在webapps目录下创建与.war文件同名的目录来存放解压后的应用文件。但是，ROOT目录是一个特例。
ROOT目录的特殊性：ROOT目录用于存放默认的Web应用程序，当访问Tomcat服务器的根URL（例如http://localhost:8080/）时，Tomcat会默认加载ROOT目录下的文件作为默认的主页。如果你将.war文件直接放入ROOT目录，Tomcat可能不会自动解压该文件，因为ROOT目录通常用于存放静态资源和默认页面，而不是作为自动部署目录。
没有自动解压.war文件：如果你将.war文件放入ROOT目录，Tomcat可能不会像在webapps目录下那样自动解压.war文件。这意味着.war文件需要手动解压，或者通过配置Tomcat来实现自动解压。
配置问题：如果Tomcat的配置文件（如server.xml）没有正确设置，或者.war文件的放置位置不正确，也可能导致.war文件不被自动解压。例如，如果.war文件没有放在webapps目录或其子目录下，Tomcat可能不会识别并解压该文件。
权限问题：如果Tomcat服务运行的用户没有足够的权限去写入ROOT目录，那么即使.war文件被放置在ROOT目录下，Tomcat也无法解压该文件，因此不会生成对应的目录。

综上所述，如果你希望.war文件在Tomcat启动时被自动解压并部署，建议将.war文件放置在webapps目录下，而不是ROOT目录。如果确实需要将应用部署在ROOT目录下，你可能需要手动解压.war文件到ROOT目录，并确保Tomcat的配置允许这样做。

四-3、Jenkins上安装与配置Maven

yum install maven -y

mvn -version

修改Maven的下载源以便提升下载速度

vim /etc/maven/settings.xml

<mirror>
    <id>aliyunmaven</id>
    <mirrorOf>*</mirrorOf>
    <name>阿里云公共仓库</name>
    <url>https://maven.aliyun.com/repository/public</url>
</mirror>

四-4、Jenkins对从gitLab中获取到的Java项目使用Maven打包

# 进入含有pom.xml文件的目录中：
mvn clean package

Maven 是一个自动化构建工具，用于Java项目，它可以帮助我们进行项目构建、依赖管理等工作。以下是一些基本的 Maven 命令，用于将 Java 项目进行打包：

安装 Maven：
确保你已经在你的机器上安装了 Maven。可以通过在命令行中运行 mvn -v 来检查 Maven 是否已安装以及其版本。
初始化 Maven 项目：
如果你的项目不是一个 Maven 项目，你可以使用 mvn archetype:generate 命令来创建一个新的 Maven 项目，或者在现有的项目中添加 pom.xml 文件。
构建项目：
在项目的根目录下，运行以下命令来构建项目：
```
mvn clean install
```
- clean：清理项目，删除 target 目录下的所有生成的文件。
- install：安装项目包到本地仓库，这样其他项目就可以作为依赖使用它。
打包项目：
根据你想要生成的包类型，可以使用不同的 Maven 插件。以下是一些常见的打包命令：
- JAR：
```
mvn package
```
  这将根据 pom.xml 中配置的打包方式（默认为 JAR）来打包你的项目。
- WAR（对于Web应用）：
```
mvn package
```
  确保 pom.xml 中的 <packaging> 标签设置为 war。
- 可执行 JAR（包含所有依赖）：
```
mvn package
```
  使用 Maven 插件如 maven-assembly-plugin 或 maven-shade-plugin 来创建一个包含所有依赖的可执行 JAR 文件。

使用特定的 Maven 插件进行打包：
如果你需要更复杂的打包需求，比如包含所有依赖的可执行 JAR，你可以在 pom.xml 中配置相应的插件。例如，使用 maven-assembly-plugin：

<build>
    <plugins>
        <plugin>
            <artifactId>maven-assembly-plugin</artifactId>
            <configuration>
                <archive>
                    <manifest>
                        <mainClass>com.example.MainClass</mainClass>
                    </manifest>
                </archive>
                <descriptorRefs>
                    <descriptorRef>jar-with-dependencies</descriptorRef>
                </descriptorRefs>
            </configuration>
            <executions>
                <execution>
                    <id>make-assembly</id> <!-- this is used for inheritance merges -->
                    <phase>package</phase> <!-- bind to the packaging phase -->
                    <goals>
                        <goal>single</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

然后运行 mvn package 来生成包含依赖的 JAR 文件。

查看生成的包：
构建完成后，你可以在 target 目录下找到生成的包。

请根据你的具体项目需求和配置选择合适的命令和插件。如果你的项目有特定的打包需求，你可能需要在 pom.xml 文件中进行相应的配置。

执行mvn clean package之前：
在这里插入图片描述
执行之后，将在target目录下生成一个包（jar或war包或…），放入tomcat的webapps下，将会自动解析

四-5、将上面的maven打包好的Java应用包部署到Web服务器的站点中

上面的maven打包执行之后，将在target目录下生成一个包（jar或war包或…），放入Web服务器的tomcat的webapps下，将会自动解析
在这里插入图片描述

使用Jenkins的Maven任务的插件支持的功能实现更快的部署

Maven的插件会自动构建代码生成Java包
好的，以下是在Jenkins中创建和配置Maven项目任务的详细步骤：

1. 安装必要的插件

在开始之前，请确保你已经安装了以下插件：

Maven Integration plugin：用于集成Maven构建。
Git plugin：如果你的项目使用Git作为版本控制系统。

如果没有安装，可以在Jenkins的管理界面中找到“管理插件”部分进行安装。

2. 创建新任务

登录到Jenkins。
点击“新建”来创建一个新的任务。
输入任务名称，选择“构建一个Maven项目”作为项目类型，然后点击“确定”。

3. 配置源码管理

在“源码管理”部分，选择你的版本控制系统（例如Git）。
输入项目的仓库URL。
如果需要，输入凭据信息（用户名和密码或SSH私钥）。

4. 配置构建触发器

在“构建触发器”部分，你可以选择不同的触发方式：
- 轮询SCM：定期检查源代码库中的变化。
- GitHub hook trigger for GITScm polling：如果你使用GitHub，这个钩子可以在代码推送时触发构建。
- 定时构建：设置一个Cron表达式来定时触发构建。

5. 配置构建环境

在“构建环境”部分，你可以选择一些选项，例如：
- 使用私有构建目录：为了避免构建之间的冲突。
- 禁用工作目录的多配置并行使用：如果你不想并行构建多个配置。

6. 配置构建

在“构建”部分，你可以添加构建步骤：
- 使用Maven构建：选择这个选项，然后输入Maven目标和选项。例如，clean install。
- 执行shell/批处理命令：如果你需要执行额外的shell命令，可以选择这个选项。

7. 配置构建后操作

在“构建后操作”部分，你可以选择一些操作，例如：
- 邮件通知：配置发送构建结果的邮件。
- 发布JUnit测试结果：如果你的项目包含JUnit测试，可以选择这个选项来收集和报告测试结果。
- 部署：如果你需要将构建结果部署到服务器，可以选择相应的部署插件。

8. 配置Maven

在“构建”部分，点击“添加参数”按钮，然后选择“Maven版本”。
选择“Jenkins”来使用Jenkins全局配置的Maven版本，或者选择“On the machine, choose from the drop-down list”来使用构建节点上安装的Maven版本。

*“全局配置”中的JDK的配置、Maven配置

根据Jenkins机器的Maven配置来配置：

在这里插入图片描述

9. 配置Maven设置

同样在“构建”部分，点击“添加参数”按钮，然后选择“Maven Settings”。
输入Maven的settings.xml文件的路径，或者选择一个已经配置好的Maven配置。

在这里插入图片描述

具体shelll脚本示例：

#!/bin/bash
# Author: Lotus43
# Date: 2024-11-28
# Description: To deploy maven_java_webapp1 to webservers

cd /root/.jenkins/workspace/deploy_maven_webapp1/target/

staging_webserver_ip="172.16.1.7"
staging_webserver_pwd="1"

production_webserver_ip="172.16.1.8"
production_webserver_pwd="1"

case $ENVIRONMENT in
        "staging")
                sshpass -p ${staging_webserver_pwd} ssh-copy-id -i /root/.ssh/id_rsa.pub root@${staging_webserver_ip} -o StrictHostKeyChecking=no

                sshpass -p ${staging_webserver_pwd} rsync -avz *.war root@${staging_webserver_ip}:/var/lib/tomcat/webapps/
                ;;
        "production")
                sshpass -p ${production_webserver_pwd} ssh-copy-id -i /root/.ssh/id_rsa.pub root@${production_webserver_ip} -o StrictHostKeyChecking=no

                sshpass -p ${production_webserver_pwd} rsync -avz *.war root@${production_webserver_ip}:/var/lib/tomcat/webapps/
                ;;
esac

在这里插入图片描述

10. 保存并运行

配置完成后，点击“保存”按钮保存你的配置。
点击“立即构建”来手动触发一次构建，或者等待构建触发器自动触发构建。

以上步骤涵盖了在Jenkins中创建和配置Maven项目任务的基本流程。根据你的具体需求，可能还需要配置其他插件或选项。

测试执行结果：

在这里插入图片描述

在这里插入图片描述
全部输出信息如下：

Started by user admin43
Running as SYSTEM
Building in workspace /root/.jenkins/workspace/deploy_maven_webapp1
The recommended git tool is: NONE
No credentials specified
Cloning the remote Git repository
Cloning repository git@gitlab.lotus431.com:lotus43/maven_webapp1.git
 > git init /root/.jenkins/workspace/deploy_maven_webapp1 # timeout=10
Fetching upstream changes from git@gitlab.lotus431.com:lotus43/maven_webapp1.git
 > git --version # timeout=10
 > git --version # 'git version 1.8.3.1'
 > git fetch --tags --progress git@gitlab.lotus431.com:lotus43/maven_webapp1.git +refs/heads/*:refs/remotes/origin/* # timeout=10
 > git config remote.origin.url git@gitlab.lotus431.com:lotus43/maven_webapp1.git # timeout=10
 > git config --add remote.origin.fetch +refs/heads/*:refs/remotes/origin/* # timeout=10
Avoid second fetch
 > git rev-parse refs/remotes/origin/master^{commit} # timeout=10
Checking out Revision 109fd58f3e4b7780132cf4bf5242c7a6398ac465 (refs/remotes/origin/master)
 > git config core.sparsecheckout # timeout=10
 > git checkout -f 109fd58f3e4b7780132cf4bf5242c7a6398ac465 # timeout=10
Commit message: "上传新文件"
 > git rev-list --no-walk 09cf27ec805a00c94acf59cb0878376213de24ca # timeout=10
Parsing POMs
Established TCP socket on 38466
[deploy_maven_webapp1] $ /usr/lib/jvm/java-11-openjdk-11.0.23.0.9-2.el7_9.x86_64/bin/java -cp /root/.jenkins/plugins/maven-plugin/WEB-INF/lib/maven35-agent-1.14.jar:/opt/maven_3_8/apache-maven-3.8.8/boot/plexus-classworlds-2.6.0.jar:/opt/maven_3_8/apache-maven-3.8.8/conf/logging jenkins.maven3.agent.Maven35Main /opt/maven_3_8/apache-maven-3.8.8 /root/.jenkins/war/WEB-INF/lib/remoting-3160.vd76b_9ddd10cc.jar /root/.jenkins/plugins/maven-plugin/WEB-INF/lib/maven35-interceptor-1.14.jar /root/.jenkins/plugins/maven-plugin/WEB-INF/lib/maven3-interceptor-commons-1.14.jar 38466
<===[JENKINS REMOTING CAPACITY]===>channel started
Executing Maven:  -B -f /root/.jenkins/workspace/deploy_maven_webapp1/pom.xml clean package
[INFO] Scanning for projects...
[INFO] 
[INFO] --------------------< com.efsavage:hello-world-war >--------------------
[INFO] Building Hello World Web Application Repository 1.0.0
[INFO]   from pom.xml
[INFO] --------------------------------[ war ]---------------------------------
[INFO] 
[INFO] --- maven-clean-plugin:2.5:clean (default-clean) @ hello-world-war ---
[INFO] 
[INFO] --- maven-resources-plugin:2.6:resources (default-resources) @ hello-world-war ---
[WARNING] Using platform encoding (UTF-8 actually) to copy filtered resources, i.e. build is platform dependent!
[INFO] skip non existing resourceDirectory /root/.jenkins/workspace/deploy_maven_webapp1/src/main/resources
[INFO] 
[INFO] --- maven-compiler-plugin:3.1:compile (default-compile) @ hello-world-war ---
[INFO] No sources to compile
[INFO] 
[INFO] --- maven-resources-plugin:2.6:testResources (default-testResources) @ hello-world-war ---
[WARNING] Using platform encoding (UTF-8 actually) to copy filtered resources, i.e. build is platform dependent!
[INFO] skip non existing resourceDirectory /root/.jenkins/workspace/deploy_maven_webapp1/src/test/resources
[INFO] 
[INFO] --- maven-compiler-plugin:3.1:testCompile (default-testCompile) @ hello-world-war ---
[INFO] No sources to compile
[INFO] 
[INFO] --- maven-surefire-plugin:2.12.4:test (default-test) @ hello-world-war ---
[INFO] No tests to run.
[JENKINS] Recording test results
[INFO] 
[INFO] --- maven-war-plugin:2.1.1:war (default-war) @ hello-world-war ---
WARNING: An illegal reflective access operation has occurred
WARNING: Illegal reflective access by com.thoughtworks.xstream.core.util.Fields (file:/root/.m2/repository/com/thoughtworks/xstream/xstream/1.3.1/xstream-1.3.1.jar) to field java.util.Properties.defaults
WARNING: Please consider reporting this to the maintainers of com.thoughtworks.xstream.core.util.Fields
WARNING: Use --illegal-access=warn to enable warnings of further illegal reflective access operations
WARNING: All illegal access operations will be denied in a future release
[INFO] Packaging webapp
[INFO] Assembling webapp [hello-world-war] in [/root/.jenkins/workspace/deploy_maven_webapp1/target/hello-world-war-1.0.0]
[INFO] Processing war project
[INFO] Copying webapp resources [/root/.jenkins/workspace/deploy_maven_webapp1/src/main/webapp]
[INFO] Webapp assembled in [17 msecs]
[INFO] Building war: /root/.jenkins/workspace/deploy_maven_webapp1/target/hello-world-war-1.0.0.war
[INFO] WEB-INF/web.xml already added, skipping
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time:  4.216 s
[INFO] Finished at: 2024-11-28T16:31:49+08:00
[INFO] ------------------------------------------------------------------------
Waiting for Jenkins to finish collecting data
[JENKINS] Archiving /root/.jenkins/workspace/deploy_maven_webapp1/pom.xml to com.efsavage/hello-world-war/1.0.0/hello-world-war-1.0.0.pom
[JENKINS] Archiving /root/.jenkins/workspace/deploy_maven_webapp1/target/hello-world-war-1.0.0.war to com.efsavage/hello-world-war/1.0.0/hello-world-war-1.0.0.war
channel stopped
[deploy_maven_webapp1] $ /bin/sh -xe /tmp/jenkins6188584567763856980.sh
+ echo 现在已经将Java的maven项目构建完成了，下面会将要把生成的Java包传输到服务器中：
现在已经将Java的maven项目构建完成了，下面会将要把生成的Java包传输到服务器中：
+ bash -x /root/.jenkins/shell_scripts/deploy_to_webserver.sh
+ cd /root/.jenkins/workspace/deploy_maven_webapp1/target/
+ staging_webserver_ip=172.16.1.7
+ staging_webserver_pwd=1
+ production_webserver_ip=172.16.1.8
+ production_webserver_pwd=1
+ case $ENVIRONMENT in
+ sshpass -p 1 ssh-copy-id -i /root/.ssh/id_rsa.pub root@172.16.1.7 -o StrictHostKeyChecking=no
/usr/bin/ssh-copy-id: INFO: Source of key(s) to be installed: "/root/.ssh/id_rsa.pub"
/usr/bin/ssh-copy-id: INFO: attempting to log in with the new key(s), to filter out any that are already installed

/usr/bin/ssh-copy-id: WARNING: All keys were skipped because they already exist on the remote system.
		(if you think this is a mistake, you may want to use -f option)

+ sshpass -p 1 rsync -avz hello-world-war-1.0.0.war root@172.16.1.7:/var/lib/tomcat/webapps/
sending incremental file list
hello-world-war-1.0.0.war

sent 174,371 bytes  received 35 bytes  348,812.00 bytes/sec
total size is 174,997  speedup is 1.00
Finished: SUCCESS

在CentOS 7系统中，JAVA_HOME环境变量通常指向Java的安装目录。如果你已经安装了Java并且设置了JAVA_HOME环境变量，你可以通过以下几种方式来查看它：

方法1：使用echo命令

打开终端，输入以下命令：

echo $JAVA_HOME

如果JAVA_HOME环境变量已经设置，这个命令将显示Java的安装路径。

方法2：使用printenv命令

你也可以使用printenv命令来查看所有环境变量，包括JAVA_HOME：

printenv | grep JAVA_HOME

或者直接查看JAVA_HOME：

printenv JAVA_HOME

方法3：检查/etc/profile或~/.bash_profile

如果上述命令没有返回任何结果，说明JAVA_HOME环境变量可能没有设置。你可以检查全局环境变量文件/etc/profile或者用户级别的环境变量文件~/.bash_profile（或者~/.bashrc，取决于你的shell配置）来查看是否已经设置了JAVA_HOME。

打开/etc/profile文件：

cat /etc/profile | grep JAVA_HOME

或者打开用户级别的环境变量文件：

cat ~/.bash_profile | grep JAVA_HOME

或者：

cat ~/.bashrc | grep JAVA_HOME

方法4：检查Java安装目录

如果你不确定JAVA_HOME是否设置，或者想要找到Java的安装目录，你可以尝试查找Java的安装路径。Java通常安装在/usr/lib/jvm/目录下。你可以使用以下命令来查找：

ls /usr/lib/jvm/

这将列出所有安装在该目录下的Java版本。你可以根据你的需要设置JAVA_HOME环境变量为这些路径中的一个。

设置JAVA_HOME

如果你发现JAVA_HOME没有设置，你可以手动设置它。例如，如果你的Java安装在/usr/lib/jvm/java-1.8.0-openjdk-1.8.0.282.b09-1.el7_7.x86_64，你可以在你的~/.bash_profile或~/.bashrc文件中添加以下行：

export JAVA_HOME=/usr/lib/jvm/java-1.8.0-openjdk-1.8.0.282.b09-1.el7_7.x86_64

然后，运行以下命令使更改生效：

source ~/.bash_profile

或者：

source ~/.bashrc

现在，你应该可以使用echo $JAVA_HOME命令来查看JAVA_HOME的值了。

*五、SonarQube的介绍、安装与部署

SonarQube基于Java开发，需安装open JDK8及以上版本
在这里插入图片描述

SonarQube是什么

SonarQube是一个开源的平台，用于持续检查代码质量。它能够检测代码中的错误、漏洞和代码异味，支持多种编程语言，包括Java、Python、PHP、C/C++、C#、HTML、JavaScript等。SonarQube可以集成到现有的工作流程中，例如Jenkins，实现跨项目分支和拉取请求的持续代码检查。

SonarQube的安装与配置

安装SonarQube

系统要求：确保服务器满足以下条件：
- 操作系统：Windows、Linux或macOS（支持的最新版本）。
- Java Runtime Environment (JRE) 或 Java Development Kit (JDK) 1.8及以上版本。
- 至少2GB的可用内存（推荐4GB以上）。
- 至少20GB的可用磁盘空间（推荐40GB以上）。

官方SonarQube10.7规定的环境要求

在这里插入图片描述

下载SonarQube：访问SonarQube官方网站下载页面，选择合适的版本进行下载。
解压安装包：将下载的SonarQube压缩包解压到您希望安装的目录。
启动SonarQube：
- Windows用户：在命令提示符下进入到sonarqube\bin目录，执行StartSonar.bat命令。
- Linux/macOS用户：在终端下进入到sonarqube/bin目录，执行./sonar.sh start命令。
访问SonarQube：SonarQube启动后，通过浏览器访问http://localhost:9000来查看SonarQube的Web界面。

安装PostgreSQL

官网RedHat系列下载教程

# Install the repository RPM:
sudo yum install -y https://download.postgresql.org/pub/repos/yum/reporpms/EL-7-x86_64/pgdg-redhat-repo-latest.noarch.rpm

# Install PostgreSQL:
sudo yum install -y postgresql13-server

# Optionally initialize the database and enable automatic start:
sudo /usr/pgsql-13/bin/postgresql-13-setup initdb
sudo systemctl enable postgresql-13
sudo systemctl start postgresql-13

或者：

# 更换国内PostgreSQL的下载源：
rpm -ivh https://mirrors.aliyun.com/postgresql/repos/yum/reporpms/EL-7-x86_64/pgdg-redhat-repo-42.0-38PGDG.noarch.rpm

# 下载：
yum install -y postgresql13-server

配置启动PostgreSQL

初始化PostgreSQL

/usr/pgsql/bin/postgresql-13 setup initdb

那么将会确保/var/lib/pgsql/13/data/会生成初始库数据
在这里插入图片描述

在CentOS 7中安装PostgreSQL后需要执行/usr/pgsql/bin/postgresql-13 setup initdb命令的原因主要包括以下几点：

创建数据库集群：initdb命令用于创建一个新的PostgreSQL数据库集群，这包括创建数据库数据存放的目录、生成共享目录表（属于整个集群而不是任何特定数据库的表），以及创建postgres、template1和template0数据库。
初始化系统表：系统表是PostgreSQL数据库系统运行控制信息的来源，是数据库的核心组成部分。initdb通过外部调用的方式执行postgres程序，该程序进入bootstrap模型并读取postgres.bki文件来创建与填充系统表与创建模板数据库。
设置默认数据库：postgres数据库是一个默认数据库，供用户、工具和第三方应用程序使用。template1和template0被用作后续CREATE DATABASE命令复制的源数据库。
安全性考虑：出于安全原因，默认情况下，initdb创建的新集群只能由集群所有者访问。--allow-group-access选项允许与集群所有者位于同一组中的任何用户读取集群中的文件，这对于以非特权用户身份执行备份非常有用。
权限要求：initdb必须以将拥有服务器进程的用户身份运行，因为服务器需要有权访问initdb创建的文件和目录。由于服务器无法以root身份运行，因此也不能以root身份运行initdb。
环境配置：initdb还会初始化数据库集群的默认区域设置和字符集编码，这些可以在创建数据库时为每个数据库单独设置。

综上所述，initdb是PostgreSQL安装和配置过程中的关键步骤，正确使用它对于确保数据库集群正确、安全地运行至关重要。

启动

systemctl start postgresql-13

在这里插入图片描述

进入PostgreSQL创建Sonar数据库及用户

必须切换到自动生成的postgres用户登录

su postgres
# 进入PostgreSQL
psql

在这里插入图片描述

创建sonar数据库及用户

create user sonar_user with password '123';
create database sonar_db owner sonar_user;
grant all on database sonar_db to sonar_user;

在这里插入图片描述

SonarQube和JDK、数据库版本的兼容性对比

SonarQube是一个代码质量管理平台，它能够分析代码的质量、潜在的漏洞、代码异味等问题。以下是SonarQube与JDK和数据库版本的兼容性对比：

JDK兼容性

SonarQube Server：根据官方文档，SonarQube服务器需要Java版本11，而SonarQube扫描器需要Java版本11或17。
SonarQube Scanners：对于SonarQube扫描器，Oracle JRE或OpenJDK的Java 17 LTS是被支持的。

数据库兼容性

PostgreSQL：SonarQube支持PostgreSQL的多个版本，包括13、12、11、10和9.6。需要注意的是，PostgreSQL必须配置为使用UTF-8字符集。
Microsoft SQL Server：支持2019 (MSSQL Server 15.0)、2017 (MSSQL Server 14.0)、2016 (MSSQL Server 13.0) 和2014 (MSSQL Server 12.0)版本，且都支持Express Edition。
MySQL：从SonarQube 7.9版本开始，SonarQube不再支持MySQL数据库。在此之前的版本，即7.8及以下版本，支持MySQL的版本在5.6到8.0之间。因此，如果您使用的是SonarQube 7.9或更高版本，官方推荐使用其他数据库，如Oracle, SQL Server, 或PostgreSQL。

总结

对于JDK，SonarQube服务器和扫描器主要支持Java 11和17版本。
对于数据库，SonarQube支持多种数据库，但需要注意的是，从7.9版本开始，SonarQube不再支持MySQL。对于PostgreSQL和Microsoft SQL Server，SonarQube支持多个版本，但具体支持的版本可能因SonarQube的版本不同而有所差异。

在部署SonarQube时，确保根据您的SonarQube版本选择合适的JDK和数据库版本，以确保最佳的兼容性和性能。

配置SonarQube并启动

修改配置文件：SonarQube的配置文件位于conf/sonar.properties。在这个文件中，您可以设置数据库连接信息、邮件服务器、插件等。例如，要配置数据库连接，可以修改以下属性：
```
# Database configuration
sonar.jdbc.url=jdbc:mysql://localhost:3306/sonar?useSSL=false&serverTimezone=UTC
sonar.jdbc.driverClassName=com.mysql.jdbc.Driver
sonar.jdbc.username=sonar
sonar.jdbc.password=sonar
```

在这里插入图片描述

更新插件：SonarQube提供了丰富的插件来支持不同的编程语言和框架。您可以通过Web界面或命令行来安装、更新和卸载插件。例如，要安装一个名为sonar-php-plugin的插件，可以执行以下命令：
```
./sonar.sh plugin install sonar-php-plugin-x.y.z.jar
```
其中x.y.z表示插件的版本号。安装完成后，重启SonarQube服务使插件生效。
配置项目分析：在SonarQube中配置项目分析，以便在代码提交时自动触发代码质量分析。

以上步骤提供了SonarQube的基本安装和配置指南。根据您的具体需求，可能还需要进行更详细的配置和优化。

*配置JDK的JAVA_HOME环境变量（源码安装时）：

在这里插入图片描述

*优化系统文件描述符等参数便于提高SonarQube的运行速度：

官网安装SonarQube10.7前的操作
在这里插入图片描述

sysctl -w vm.max_map_count=524288

sysctl -w fs.file-max=131072

ulimit -n 131072

ulimit -u 8192

grep SECCOMP /boot/config-$(uname -r)

yum install fontconfig

在这里插入图片描述

解释：

创建Sonar用户、启动SonarQube

useradd sonar
chown -R sonar:sonar /app
su - sonar -c "/app/sonar_qube10_1/sonarqube-10.1.0.73491/bin/linux-x86-64/sonar.sh start"

在这里插入图片描述

访问SonarQube页面进行下一步操作

xx本地IPxxx:9000

在这里插入图片描述

默认用户名及密码: admin admin

登录后重置密码：
在这里插入图片描述

在这里插入图片描述

生成Token

以配合后续所需代码质检的机器（比如Jenkins）使用代码质检命令时调用
在这里插入图片描述

squ_ba285990c44e208d6b1535983ec85eea36dfc91a

创建SonarQube项目

选择“Manually”创建项目
在这里插入图片描述

在这里插入图片描述

选择“Other CI”

将上面生成的token填写到项目token中：
在这里插入图片描述
选择项目类型，如：Maven，会生成Maven项目进行代码质检时所需对应的一系列命令：

在Jenkins机器中有这个Maven项目代码目录，执行对应的远程质检命令：

cd /root/.jenins/workspace/xxxx

mvn clean verify sonar:sonar \
  -Dsonar.projectKey=for_maven_webapp1 \
  -Dsonar.projectName='for_maven_webapp1' \
  -Dsonar.host.url=http://10.0.0.111:9000 \
  -Dsonar.token=squ_ba285990c44e208d6b1535983ec85eea36dfc91a
# 或单行执行：
mvn clean verify sonar:sonar -Dsonar.projectKey=for_maven_webapp1 -Dsonar.projectName='for_maven_webapp1' -Dsonar.host.url=http://10.0.0.111:9000 -Dsonar.token=squ_ba285990c44e208d6b1535983ec85eea36dfc91a

代码质检结果：
在这里插入图片描述

SonarQube网页中显示代码质检结果：

五、Jenkins在Maven任务中使用SonarQube插件进行代码质检

五-1、基本介绍

要在Jenkins中使用Sonar插件结合Maven项目进行代码质量分析，可以按照以下步骤进行详细操作：

1. 安装SonarQube Scanner插件

首先，需要在Jenkins中安装SonarQube Scanner插件。进入Jenkins的“系统管理”->“插件管理”，搜索并安装SonarQube Scanner插件。安装完成后，重启Jenkins以使插件生效。

2. 配置SonarQube服务器信息

在Jenkins中配置SonarQube服务器信息。进入“系统管理”->“系统配置”，在“SonarQube servers”部分点击“Add SonarQube”，填写SonarQube服务器的名称、URL和身份验证凭据（Token或用户名密码）。
在这里插入图片描述

3. 生成SonarQube Token

在SonarQube中生成一个Token，用于Jenkins与SonarQube的集成。登录SonarQube，进入“我的账号”->“安全”，在“Generate Tokens”中输入一个名称，然后点击“Generate”，生成一个Token，并记录下来。

4. 配置Jenkins凭证

在Jenkins中添加SonarQube Token作为全局凭证。进入“系统管理”->“管理凭证”，点击“全局”，再点击“添加凭证”，选择“Secret text”类型，输入刚才生成的SonarQube Token作为Secret，并保存。
在这里插入图片描述

5. 配置Maven项目

在Maven项目的pom.xml文件中添加SonarQube Scanner for Maven插件的配置：

<build>
  <pluginManagement>
    <plugins>
      <plugin>
        <groupId>org.sonarsource.scanner.maven</groupId>
        <artifactId>sonar-maven-plugin</artifactId>
        <version>3.7.0.1746</version>
      </plugin>
    </plugins>
  </pluginManagement>
</build>

这样可以锁定SonarQube Scanner插件的版本。

6. 编写Jenkins Pipeline脚本

在Jenkins中新建一个流水线项目，并加入以下Pipeline脚本：

pipeline {
    agent any
    environment {
        def projectPath = '/home/jenkins_deploy/workspace/test'
        def mvnHome = '/home/jenkins_deploy/software/apache-maven-3.6.3'
        def sonarScannerPath = '/opt/sonar-scanner'
    }
    tools {
        jdk "jdk8"
    }
    stages {
        stage('拉取代码') {
            steps {
                git branch: 'test', credentialsId: 'gitToken', url: '<-EMAIL->/rabbitmq.git'
            }
        }
        stage('打包编译') {
            steps {
                sh "cd $projectPath && $mvnHome/bin/mvn clean package -Dmaven.test.skip=true -f pom.xml"
            }
        }
        stage('代码扫描') {
            steps {
                withSonarQubeEnv('sonarqube') {
                    sh "cd $projectPath && ${sonarScannerPath}/bin/sonar-scanner -X " +
                        "-Dsonar.projectKey=test" +
                        "-Dsonar.projectName=test" +
                        "-Dsonar.sources=. " +
                        "-Dsonar.sourceEncoding=UTF-8 " +
                        "-Dsonar.java.binaries=target/"
                }
                sleep(10) // 这个睡眠是为了防止没有分析完成就去请求结果
                timeout(time: 5, unit: 'MINUTES') {
                    script {
                        def qg = waitForQualityGate()
                        if (qg.status != 'OK') {
                            error "Pipeline aborted due to a quality gate failure: ${qg.status}"
                        }
                    }
                }
            }
        }
    }
}

这个脚本包括了拉取代码、Maven打包编译、代码质量检测等步骤。

7. 构建项目

点击Jenkins项目，立即构建。构建完成后，可以在Jenkins项目的主页中看到关于SonarQube分析结果的链接或小部件，点击链接或查看小部件以查看详细的代码质量报告。

通过以上步骤，你可以在Jenkins中使用Sonar插件结合Maven项目进行代码质量分析。

五-2、具体配置

在这里插入图片描述

"Pre Steps"中配置SonarQube

在这里插入图片描述
因为使用的是“SonarQube Server”而不是“SonarQube Scanner”，所以选择“调用顶层Mavenen目标”，然后输入代码质检命令

五-3、执行结果

在这里插入图片描述

具体控制台输出信息示例：

Started by user admin43
Running as SYSTEM
Building in workspace /root/.jenkins/workspace/deploy_maven_webapp1
The recommended git tool is: NONE
No credentials specified
Cloning the remote Git repository
Cloning repository git@gitlab.lotus431.com:lotus43/maven_webapp1.git
 > git init /root/.jenkins/workspace/deploy_maven_webapp1 # timeout=10
Fetching upstream changes from git@gitlab.lotus431.com:lotus43/maven_webapp1.git
 > git --version # timeout=10
 > git --version # 'git version 1.8.3.1'
 > git fetch --tags --progress git@gitlab.lotus431.com:lotus43/maven_webapp1.git +refs/heads/*:refs/remotes/origin/* # timeout=10
 > git config remote.origin.url git@gitlab.lotus431.com:lotus43/maven_webapp1.git # timeout=10
 > git config --add remote.origin.fetch +refs/heads/*:refs/remotes/origin/* # timeout=10
Avoid second fetch
 > git rev-parse refs/remotes/origin/master^{commit} # timeout=10
Checking out Revision 17ca7b29320f97c065c15563171dd925a454286b (refs/remotes/origin/master)
 > git config core.sparsecheckout # timeout=10
 > git checkout -f 17ca7b29320f97c065c15563171dd925a454286b # timeout=10
Commit message: "更新 index.jsp"
 > git rev-list --no-walk 17ca7b29320f97c065c15563171dd925a454286b # timeout=10
[deploy_maven_webapp1] $ /opt/maven_3_8/apache-maven-3.8.8/bin/mvn -gs /opt/maven_3_8/apache-maven-3.8.8/conf/settings.xml clean verify sonar:sonar -Dsonar.projectKey=for_maven_webapp1 -Dsonar.projectName=for_maven_webapp1 -Dsonar.host.url=http://10.0.0.111:9000 -Dsonar.token=squ_ba285990c44e208d6b1535983ec85eea36dfc91a
[INFO] Scanning for projects...
[WARNING] The artifact org.codehaus.mojo:sonar-maven-plugin:jar:4.0.0.4121 has been relocated to org.sonarsource.scanner.maven:sonar-maven-plugin:jar:4.0.0.4121: SonarQube plugin was moved to SonarSource organisation
[INFO] 
[INFO] --------------------< com.efsavage:hello-world-war >--------------------
[INFO] Building Hello World Web Application Repository 1.0.0
[INFO]   from pom.xml
[INFO] --------------------------------[ war ]---------------------------------
[INFO] 
[INFO] --- maven-clean-plugin:2.5:clean (default-clean) @ hello-world-war ---
[INFO] 
[INFO] --- maven-resources-plugin:2.6:resources (default-resources) @ hello-world-war ---
[WARNING] Using platform encoding (UTF-8 actually) to copy filtered resources, i.e. build is platform dependent!
[INFO] skip non existing resourceDirectory /root/.jenkins/workspace/deploy_maven_webapp1/src/main/resources
[INFO] 
[INFO] --- maven-compiler-plugin:3.1:compile (default-compile) @ hello-world-war ---
[INFO] No sources to compile
[INFO] 
[INFO] --- maven-resources-plugin:2.6:testResources (default-testResources) @ hello-world-war ---
[WARNING] Using platform encoding (UTF-8 actually) to copy filtered resources, i.e. build is platform dependent!
[INFO] skip non existing resourceDirectory /root/.jenkins/workspace/deploy_maven_webapp1/src/test/resources
[INFO] 
[INFO] --- maven-compiler-plugin:3.1:testCompile (default-testCompile) @ hello-world-war ---
[INFO] No sources to compile
[INFO] 
[INFO] --- maven-surefire-plugin:2.12.4:test (default-test) @ hello-world-war ---
[INFO] No tests to run.
[INFO] 
[INFO] --- maven-war-plugin:2.1.1:war (default-war) @ hello-world-war ---
WARNING: An illegal reflective access operation has occurred
WARNING: Illegal reflective access by com.thoughtworks.xstream.core.util.Fields (file:/root/.m2/repository/com/thoughtworks/xstream/xstream/1.3.1/xstream-1.3.1.jar) to field java.util.Properties.defaults
WARNING: Please consider reporting this to the maintainers of com.thoughtworks.xstream.core.util.Fields
WARNING: Use --illegal-access=warn to enable warnings of further illegal reflective access operations
WARNING: All illegal access operations will be denied in a future release
[INFO] Packaging webapp
[INFO] Assembling webapp [hello-world-war] in [/root/.jenkins/workspace/deploy_maven_webapp1/target/hello-world-war-1.0.0]
[INFO] Processing war project
[INFO] Copying webapp resources [/root/.jenkins/workspace/deploy_maven_webapp1/src/main/webapp]
[INFO] Webapp assembled in [19 msecs]
[INFO] Building war: /root/.jenkins/workspace/deploy_maven_webapp1/target/hello-world-war-1.0.0.war
[INFO] WEB-INF/web.xml already added, skipping
[INFO] 
[INFO] --------------------< com.efsavage:hello-world-war >--------------------
[INFO] Building Hello World Web Application Repository 1.0.0
[INFO]   from pom.xml
[INFO] --------------------------------[ war ]---------------------------------
[INFO] 
[INFO] --- sonar-maven-plugin:4.0.0.4121:sonar (default-cli) @ hello-world-war ---
[WARNING] 15:48:38.479 Using an unspecified version instead of an explicit plugin version may introduce breaking analysis changes at an unwanted time. It is highly recommended to use an explicit version, e.g. 'org.sonarsource.scanner.maven:sonar-maven-plugin:4.0.0.4121'.
[INFO] 15:48:38.536 Java 11.0.23 Red Hat, Inc. (64-bit)
[INFO] 15:48:38.536 Linux 3.10.0-957.el7.x86_64 (amd64)
[INFO] 15:48:38.963 User cache: /root/.sonar/cache
[INFO] 15:48:39.108 Communicating with SonarQube Server 10.1.0.73491
[INFO] 15:48:39.145 Default locale: "en_US", source code encoding: "UTF-8" (analysis is platform dependent)
[INFO] 15:48:40.019 Load global settings
[INFO] 15:48:40.083 Load global settings (done) | time=63ms
[INFO] 15:48:40.084 Server id: 147B411E-AZN1gMbmq0fcUlzEoWjh
[INFO] 15:48:40.087 User cache: /root/.sonar/cache
[INFO] 15:48:40.089 Load/download plugins
[INFO] 15:48:40.089 Load plugins index
[INFO] 15:48:40.127 Load plugins index (done) | time=38ms
[INFO] 15:48:40.300 Load/download plugins (done) | time=211ms
[INFO] 15:48:41.517 Process project properties
[INFO] 15:48:41.525 Process project properties (done) | time=8ms
[INFO] 15:48:41.526 Execute project builders
[INFO] 15:48:41.527 Execute project builders (done) | time=1ms
[INFO] 15:48:41.529 Project key: for_maven_webapp1
[INFO] 15:48:41.529 Base dir: /root/.jenkins/workspace/deploy_maven_webapp1
[INFO] 15:48:41.529 Working dir: /root/.jenkins/workspace/deploy_maven_webapp1/target/sonar
[INFO] 15:48:41.561 Load project settings for component key: 'for_maven_webapp1'
[INFO] 15:48:41.576 Load project settings for component key: 'for_maven_webapp1' (done) | time=15ms
[INFO] 15:48:41.936 Auto-configuring with CI 'Jenkins'
[INFO] 15:48:41.938 Load quality profiles
[INFO] 15:48:42.026 Load quality profiles (done) | time=88ms
[INFO] 15:48:42.035 Load active rules
[INFO] 15:48:43.900 Load active rules (done) | time=1865ms
[INFO] 15:48:43.903 Load analysis cache
[INFO] 15:48:43.915 Load analysis cache (404) | time=12ms
[INFO] 15:48:44.031 Load project repositories
[INFO] 15:48:44.074 Load project repositories (done) | time=43ms
[INFO] 15:48:44.163 Indexing files...
[INFO] 15:48:44.177 Project configuration:
[INFO] 15:48:44.580 4 files indexed
[INFO] 15:48:44.581 0 files ignored because of scm ignore settings
[INFO] 15:48:44.582 Quality profile for jsp: Sonar way
[INFO] 15:48:44.582 Quality profile for xml: Sonar way
[INFO] 15:48:44.582 ------------- Run sensors on module for_maven_webapp1
[INFO] 15:48:44.818 Load metrics repository
[INFO] 15:48:44.865 Load metrics repository (done) | time=47ms
[INFO] 15:48:49.318 Sensor JaCoCo XML Report Importer [jacoco]
[INFO] 15:48:49.323 'sonar.coverage.jacoco.xmlReportPaths' is not defined. Using default locations: target/site/jacoco/jacoco.xml,target/site/jacoco-it/jacoco.xml,build/reports/jacoco/test/jacocoTestReport.xml
[INFO] 15:48:49.324 No report imported, no coverage information will be imported by JaCoCo XML Report Importer
[INFO] 15:48:49.324 Sensor JaCoCo XML Report Importer [jacoco] (done) | time=6ms
[INFO] 15:48:49.324 Sensor CSS Rules [javascript]
[INFO] 15:48:49.324 No CSS, PHP, HTML or VueJS files are found in the project. CSS analysis is skipped.
[INFO] 15:48:49.324 Sensor CSS Rules [javascript] (done) | time=0ms
[INFO] 15:48:49.324 Sensor C# Project Type Information [csharp]
[INFO] 15:48:49.349 Sensor C# Project Type Information [csharp] (done) | time=25ms
[INFO] 15:48:49.349 Sensor C# Analysis Log [csharp]
[INFO] 15:48:49.380 Sensor C# Analysis Log [csharp] (done) | time=31ms
[INFO] 15:48:49.381 Sensor C# Properties [csharp]
[INFO] 15:48:49.381 Sensor C# Properties [csharp] (done) | time=0ms
[INFO] 15:48:49.381 Sensor HTML [web]
[INFO] 15:48:49.473 Sensor HTML [web] (done) | time=92ms
[INFO] 15:48:49.473 Sensor XML Sensor [xml]
[INFO] 15:48:49.656 2 source files to be analyzed
[INFO] 15:48:49.868 2/2 source files have been analyzed
[INFO] 15:48:49.871 Sensor XML Sensor [xml] (done) | time=398ms
[INFO] 15:48:49.871 Sensor TextAndSecretsSensor [text]
[INFO] 15:48:49.912 3 source files to be analyzed
[INFO] 15:48:49.912 3/3 source files have been analyzed
[INFO] 15:48:49.913 Sensor TextAndSecretsSensor [text] (done) | time=42ms
[INFO] 15:48:49.913 Sensor VB.NET Project Type Information [vbnet]
[INFO] 15:48:49.916 Sensor VB.NET Project Type Information [vbnet] (done) | time=3ms
[INFO] 15:48:49.916 Sensor VB.NET Analysis Log [vbnet]
[INFO] 15:48:49.931 Sensor VB.NET Analysis Log [vbnet] (done) | time=15ms
[INFO] 15:48:49.931 Sensor VB.NET Properties [vbnet]
[INFO] 15:48:49.931 Sensor VB.NET Properties [vbnet] (done) | time=0ms
[INFO] 15:48:49.931 Sensor IaC Docker Sensor [iac]
[INFO] 15:48:49.938 0 source files to be analyzed
[INFO] 15:48:50.038 0/0 source files have been analyzed
[INFO] 15:48:50.039 Sensor IaC Docker Sensor [iac] (done) | time=108ms
[INFO] 15:48:50.042 ------------- Run sensors on project
[INFO] 15:48:50.118 Sensor Analysis Warnings import [csharp]
[INFO] 15:48:50.119 Sensor Analysis Warnings import [csharp] (done) | time=1ms
[INFO] 15:48:50.119 Sensor Zero Coverage Sensor
[INFO] 15:48:50.119 Sensor Zero Coverage Sensor (done) | time=0ms
[INFO] 15:48:50.141 CPD Executor Calculating CPD for 1 file
[INFO] 15:48:50.175 CPD Executor CPD calculation finished (done) | time=32ms
[INFO] 15:48:50.432 Analysis report generated in 224ms, dir size=133.4 kB
[INFO] 15:48:50.570 Analysis report compressed in 138ms, zip size=19.3 kB
[INFO] 15:48:50.607 Analysis report uploaded in 35ms
[INFO] 15:48:50.625 ANALYSIS SUCCESSFUL, you can find the results at: http://10.0.0.111:9000/dashboard?id=for_maven_webapp1
[INFO] 15:48:50.626 Note that you will be able to access the updated dashboard once the server has processed the submitted analysis report
[INFO] 15:48:50.626 More about the report processing at http://10.0.0.111:9000/api/ce/task?id=AZN25N0ZyqgW84wLMZ0-
[INFO] 15:48:50.664 Analysis total time: 10.150 s
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time:  14.360 s
[INFO] Finished at: 2024-11-29T15:48:50+08:00
[INFO] ------------------------------------------------------------------------
Parsing POMs
Established TCP socket on 46832
[deploy_maven_webapp1] $ /usr/lib/jvm/java-11-openjdk-11.0.23.0.9-2.el7_9.x86_64/bin/java -cp /root/.jenkins/plugins/maven-plugin/WEB-INF/lib/maven35-agent-1.14.jar:/opt/maven_3_8/apache-maven-3.8.8/boot/plexus-classworlds-2.6.0.jar:/opt/maven_3_8/apache-maven-3.8.8/conf/logging jenkins.maven3.agent.Maven35Main /opt/maven_3_8/apache-maven-3.8.8 /root/.jenkins/war/WEB-INF/lib/remoting-3160.vd76b_9ddd10cc.jar /root/.jenkins/plugins/maven-plugin/WEB-INF/lib/maven35-interceptor-1.14.jar /root/.jenkins/plugins/maven-plugin/WEB-INF/lib/maven3-interceptor-commons-1.14.jar 46832
<===[JENKINS REMOTING CAPACITY]===>channel started
Executing Maven:  -B -f /root/.jenkins/workspace/deploy_maven_webapp1/pom.xml clean package
[INFO] Scanning for projects...
[INFO] 
[INFO] --------------------< com.efsavage:hello-world-war >--------------------
[INFO] Building Hello World Web Application Repository 1.0.0
[INFO]   from pom.xml
[INFO] --------------------------------[ war ]---------------------------------
[INFO] 
[INFO] --- maven-clean-plugin:2.5:clean (default-clean) @ hello-world-war ---
[INFO] Deleting /root/.jenkins/workspace/deploy_maven_webapp1/target
[INFO] 
[INFO] --- maven-resources-plugin:2.6:resources (default-resources) @ hello-world-war ---
[WARNING] Using platform encoding (UTF-8 actually) to copy filtered resources, i.e. build is platform dependent!
[INFO] skip non existing resourceDirectory /root/.jenkins/workspace/deploy_maven_webapp1/src/main/resources
[INFO] 
[INFO] --- maven-compiler-plugin:3.1:compile (default-compile) @ hello-world-war ---
[INFO] No sources to compile
[INFO] 
[INFO] --- maven-resources-plugin:2.6:testResources (default-testResources) @ hello-world-war ---
[WARNING] Using platform encoding (UTF-8 actually) to copy filtered resources, i.e. build is platform dependent!
[INFO] skip non existing resourceDirectory /root/.jenkins/workspace/deploy_maven_webapp1/src/test/resources
[INFO] 
[INFO] --- maven-compiler-plugin:3.1:testCompile (default-testCompile) @ hello-world-war ---
[INFO] No sources to compile
[INFO] 
[INFO] --- maven-surefire-plugin:2.12.4:test (default-test) @ hello-world-war ---
[INFO] No tests to run.
[JENKINS] Recording test results
[INFO] 
[INFO] --- maven-war-plugin:2.1.1:war (default-war) @ hello-world-war ---
WARNING: An illegal reflective access operation has occurred
WARNING: Illegal reflective access by com.thoughtworks.xstream.core.util.Fields (file:/root/.m2/repository/com/thoughtworks/xstream/xstream/1.3.1/xstream-1.3.1.jar) to field java.util.Properties.defaults
WARNING: Please consider reporting this to the maintainers of com.thoughtworks.xstream.core.util.Fields
WARNING: Use --illegal-access=warn to enable warnings of further illegal reflective access operations
WARNING: All illegal access operations will be denied in a future release
[INFO] Packaging webapp
[INFO] Assembling webapp [hello-world-war] in [/root/.jenkins/workspace/deploy_maven_webapp1/target/hello-world-war-1.0.0]
[INFO] Processing war project
[INFO] Copying webapp resources [/root/.jenkins/workspace/deploy_maven_webapp1/src/main/webapp]
[INFO] Webapp assembled in [21 msecs]
[INFO] Building war: /root/.jenkins/workspace/deploy_maven_webapp1/target/hello-world-war-1.0.0.war
[INFO] WEB-INF/web.xml already added, skipping
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time:  4.913 s
[INFO] Finished at: 2024-11-29T15:49:00+08:00
[INFO] ------------------------------------------------------------------------
Waiting for Jenkins to finish collecting data
[JENKINS] Archiving /root/.jenkins/workspace/deploy_maven_webapp1/pom.xml to com.efsavage/hello-world-war/1.0.0/hello-world-war-1.0.0.pom
[JENKINS] Archiving /root/.jenkins/workspace/deploy_maven_webapp1/target/hello-world-war-1.0.0.war to com.efsavage/hello-world-war/1.0.0/hello-world-war-1.0.0.war
channel stopped
[deploy_maven_webapp1] $ /bin/sh -xe /tmp/jenkins14307543287375321376.sh
+ echo 现在已经将Java的maven项目构建完成了，下面会将要把生成的Java包传输到服务器中：
现在已经将Java的maven项目构建完成了，下面会将要把生成的Java包传输到服务器中：
+ bash -x /root/.jenkins/shell_scripts/deploy_to_webserver.sh
+ cd /root/.jenkins/workspace/deploy_maven_webapp1/target/
+ staging_webserver_ip=172.16.1.7
+ staging_webserver_pwd=1
+ production_webserver_ip=172.16.1.8
+ production_webserver_pwd=1
+ case $ENVIRONMENT in
+ sshpass -p 1 ssh-copy-id -i /root/.ssh/id_rsa.pub root@172.16.1.7 -o StrictHostKeyChecking=no
/usr/bin/ssh-copy-id: INFO: Source of key(s) to be installed: "/root/.ssh/id_rsa.pub"
/usr/bin/ssh-copy-id: INFO: attempting to log in with the new key(s), to filter out any that are already installed

/usr/bin/ssh-copy-id: WARNING: All keys were skipped because they already exist on the remote system.
		(if you think this is a mistake, you may want to use -f option)

+ sshpass -p 1 rsync -avz hello-world-war-1.0.0.war root@172.16.1.7:/var/lib/tomcat/webapps/
sending incremental file list
hello-world-war-1.0.0.war

sent 174,374 bytes  received 35 bytes  348,818.00 bytes/sec
total size is 175,001  speedup is 1.00
Sending e-mails to: 2048935747@qq.com
Finished: SUCCESS

六、Jenkins的Pipeline任务的使用

六-1、什么是Pipeline项目

在这里插入图片描述

六-2、Jenins的Pipeline任务的配置与使用

创建Pipeline类型的任务：

在这里插入图片描述

可以使用“流水线语法”页面自动生成不同功能对应的Pipeline脚本：

示例：
从Git仓库中拉取代码：
在这里插入图片描述
执行shell命令脚本：

详细Pipeline脚本示例

pipeline{
    agent any
    stages{
        stage("从GitLab中拉取webapp1的代码"){
            steps{
                git 'git@gitlab.lotus431.com:lotus43/maven_webapp1.git'
            }
        }
        stage("使用SonarQube进行代码质检"){
            steps{
                sh '''/opt/maven_3_8/apache-maven-3.8.8/bin/mvn clean verify sonar:sonar -Dsonar.projectKey=for_maven_webapp1 -Dsonar.projectName=\'for_maven_webapp1\' -Dsonar.host.url=http://10.0.0.111:9000 -Dsonar.token=squ_ba285990c44e208d6b1535983ec85eea36dfc91a
'''
            }
        }
        stage("使用mavaen进行构建代码包"){
            steps{
                sh '''/opt/maven_3_8/apache-maven-3.8.8/bin/mvn clean package'''
            }
        }
        stage("将mavaen构建的代码包部署到Web服务器中"){
            steps{
                sh '''bash -x /root/.jenkins/shell_scripts/deploy_to_webserver.sh
'''
            }

        }
    }
}