基于Jenkins+GitLab+Maven实现代码自动打包编译发布

Jenkins 可以通过本机系统包、Docker 安装，甚至可以由任何安装了 Java 运行时环境 (JRE) 的机器独立运行。

（一）Jenkins功能

Jenkins是一个开源的持续集成工具，它可以在自动化构建，测试和部署软件的过程中发挥重要的作用。Jenkins允许软件开发人员自动构建，测试和发布他们的代码，而无需进行手动的操作。主要功能包括：

1、持续集成：可以在代码修改后自动进行构建、测试和部署。

2、自动化部署：可以将软件部署到指定的服务器上。

3、测试报告：可以生成测试报告，并将测试结果自动反馈给相关开发人员。

4、软件包管理：可以管理版本控制系统和软件包依赖性。

5、插件支持：可以通过插件扩展Jenkins的功能。

（二）Jenkins官网地址

Jenkins官网地址如下：

 

https://www.jenkins.io/

 

进入官网后，可以点击https://www.jenkins.io/zh/doc/book/进入中文用户文档页面查看相关帮助信息。

（三）Jenkins安装条件

Jenkins可以运行在各种不同的操作系统上，包括Windows、Linux、MacOS等。只要环境配置正确，Jenkins就可以在各种操作系统上运行。系统对软件和硬件的要求并不高，具体要求如下：

系统要求（最低推荐配置）: 256MB可用内存/1GB可用磁盘空间(作为一个Docker容器运行jenkins的话推荐10GB) 如果是小团队使用，则推荐的硬件配置：1GB+可用内存/50GB+ 可用磁盘空间

软件配置： 软件方面需要Java运行环境支持，Java运行时环境（JRE）或Java开发工具包（JDK）都可以。

（四）Jenkins的发行版本

Jenkins项目产生两个发行线, 长期支持版本 (LTS) 和每周更新版本。

稳定版 (LTS) LTS (长期支持) 版本每12周从常规版本流中选择，作为该时间段的稳定版本。每隔 4 周，我们会发布稳定版本，其中包括错误和安全修复反向移植。

定期发布 (每周) 每周都会发布一个新版本，为用户和插件开发人员提供错误修复和功能。

（五）Jenkins演示项目部署环境拓扑

本文所有演示环境基于Centos7.6系统部署，以下为拓扑结构：

本实验将针对如上拓扑，进行如下实验，跑通Jenkins整个持续集成项目。

大概有如下步骤：

1、首先，开发人员角色进行代码提交，提交到Git远程仓库。

2、然后，Jenkins作为持续集成工具，使用Git工具到Git仓库拉取代码到集成服务器，再配合JDK，Maven等软件完成代码编译，打包等工作，在这个过程中每一步出错，都重新再执行一次整个流程。

3、最后，Jenkins把生成的jar或war包分发到测试服务器或者生产服务器，测试人员或用户就可以访问应用。

二、GitLab安装部署

以下操作在192.168.20.231服务器上完成。

（一）GitLab介绍

GitLab是一个开源的git仓库管理软件，并提供web界面，方便管理git仓库。和github很相似，不过github暂时没有开源版本，项目必须托管到github官方网站，不能本地部署。很多公司考虑到安全费用等因素，搭建自己的gitlab服务器。

1、GitLab官方地址为

 

https://about.gitlab.com/

（二）GitLab安装 1、安装相关依赖软件

yum install -y openssh-server openssh-clients postfix cronie policycoreutils-python

 

 

2、启动sshd服务并且设置为开机自启动

 

systemctl enable sshd && sudo systemctl start sshd

3、启动邮件服务并且设置为开机自启动

systemctl enable postfix && systemctl start postfix

 

4、做好相关服务的防火墙策略，我这里直接将防火墙关闭

 

firewall-cmd --add-service=ssh --permanent
firewall-cmd --add-service=http --permanent
firewall-cmd --reload

5、下载gitlab的rpm包

1）可以从gtilab官方网站下载相应gitlab版本的rpm包，地址如下

https://packages.gitlab.com/gitlab/gitlab-ce

  2）也可以从国内镜像站下载相应gitlab版本的rpm包，地址如下

https://mirrors.tuna.tsinghua.edu.cn/gitlab-ce/yum/

 

选择对应版本，复制下载链接即可

复制15.11.13版本下载链接如下：

 

https://mirrors.tuna.tsinghua.edu.cn/gitlab-ce/yum/el7/gitlab-ce-15.11.13-ce.0.el7.x86_64.rpm

 

 

通过wget命令进行下载

 

wget https://mirrors.tuna.tsinghua.edu.cn/gitlab-ce/yum/el7/gitlab-ce-15.11.13-ce.0.el7.x86_64.rpm --no-check-certificate

 

6、通过rpm命令进行安装即可

 

rpm -ivh gitlab-ce-15.11.13-ce.0.el7.x86_64.rpm

 

7、修改配置文件/etc/gitlab/gitlab.rb访问地址及访问端口，这里我改为85端口

 

external_url 'http://192.168.20.231:85'

nginx['listen_port'] = 85

 

8、重新加载配置文件

 

gitlab-ctl reconfigure

 

9、重启GitLab服务

 

gitlab-ctl restart

 

10、登录GitLab

  通过浏览器访问http://192.168.20.231:85 这里管理员用户默认为root，密码可以在文件/etc/gitlab/initial_root_password中查看，如下：

 

[root@master ruanjianfile]# cat /etc/gitlab/initial_root_password
# WARNING: This value is valid only in the following conditions
#          1. If provided manually (either via `GITLAB_ROOT_PASSWORD` environment variable or via `gitlab_rails['initial_root_password']` setting in `gitlab.rb`, it was provided before database was seeded for the first time (usually, the first reconfigure run).
#          2. Password hasn't been changed manually, either via UI or via command line.
#
#          If the password shown here doesn't work, you must reset the admin password following https://docs.gitlab.com/ee/security/reset_user_password.html#reset-your-root-password.


Password: vlrcciD02sCJheisy8cEZvoZ7CaehHIEfdUxzDEQRCM=


# NOTE: This file will be automatically deleted in the first reconfigure run after 24 hours.

 

 

  11、在管理页面修改默认语言为简体中文。

12、在管理页面--用户菜单，修改管理员root的密码，我这里设置为haodao123

（三）GitLab添加组

使用管理员账号root创建组，一个组里面可以有多个项目分支，可以将开发添加到组里面进行权限设置，不同的组就是公司不同的开发项目或者服务模块，不同的组添加不同的开发即可实现对开发权限的管理。

1、root账号登录进入后台

2、编写组相关信息创建即可

3、选择对应组，创建项目，如下：

（四）新建用户

1、切换到管理菜单，选择用户选项；

  2、填写用户相关信息，创建即可。

  3、在新增用户界面，选择编辑，为新创建用户添加密码；

我这里密码是hh123456

（五）将新建用户添加到组里

1、找到对应组，成员信息

2、添加成员到组里

3、切换到huanghao账号登录，已经可以看到huanghao这个账号在组里面了

 （六）将源码上传到GitLab仓库

IDEA中创建项目，大家可以先看后面章节再回过来操作。

1、IDEA编辑器中创建了一个简单web项目

2、IDEA编辑器中找到VCS菜单，选择如下子菜单

3、选择Git类型

前提是本地安装好Git环境

4、在对应项目中右键，找到Git，点击Add将代码放到缓存中去

5、同上一步，在对应项目中右键，找到Git，点击Commit Directory将代码提交本地仓库；

6、同上一步，在对应项目中右键，找到Git，点击Manage Remotes管理添加远程仓库；

从gitlab组中对应项目找到HTTP对应地址，编辑添加如下所示：

7、同上一步，在对应项目中右键，找到Git，点击Push

8、此时push成功，gitlab项目中可以看到如下信息

四、Git客户端安装

以下操作在192.168.20.232服务器上完成。 以下通过源码方式进行安装，注意通过yum方式安装默认安装的是低版本！

（一）卸载yum安装的低版本git

1、查看git版本

 

git --version

2、卸载git

yum remove -y git

（二）源码安装git

 

1、安装相关依赖软件

 

yum -y install libcurl-devel expat-devel curl-devel  gettext-devel openssl-devel zlib-devel

2、安装编译工具

yum -y install  gcc perl-ExtUtils-MakeMaker

3、下载Git对应版本源码，网址如下：

https://mirrors.edge.kernel.org/pub/software/scm/git/

4、找到对应版本下载链接，通过wget工具下载

wget https://mirrors.edge.kernel.org/pub/software/scm/git/git-2.39.3.tar.gz --no-check-certificate

5、对应目录下，解压源码包

tar -xzf git-2.39.3.tar.gz

6、准备编译安装

cd git-2.39.3
make prefix=/usr/local/git all
make prefix=/usr/local/git install

7、添加git到环境变量，编辑/etc/profile文件，最后加入如下内容；

export PATH=/usr/local/git/bin:$PATH

如下图所示：

 

8、使环境变量生效

 

source /etc/profile

 

9、验证git安装是否成功

 

[root@node1 ~]# git --version
git version 2.39.3
[root@node1 ~]# whereis git
git: /usr/bin/git /usr/local/git /usr/local/git/bin/git /usr/share/man/man1/git.1.gz

 

五、JDK安装部署

本套实验中，总共有两台服务器需要安装部署JDK环境，为了让大家更好学习Linux环境下软件安装部署，我这里将给大家分别展示通过yum方式及官网下载二进制包安装的方式。其中跑Jenkins服务的那一台服务器将通过yum方式安装JDK11版本，跑tomcat的那一台服务器将手动安装JDK8版本。

（一）yum方式安装部署JDK11

以下操作在192.168.20.232服务器上执行安装部署命令。前提是大家配置好yum环境。

 

yum -y install java-11-openjdk*

安装完毕执行如下命令验证是否成功安装配置好环境变量。

java -version

执行上面命令后，看到如下信息，说明安装JDK成功了。

 

通过yum方式安装好JDK11后默认安装目录如下

 

/usr/lib/jvm

 （二）JDK8安装部署

当然，大家如果嫌弃下载麻烦，也可以通过yum方式安装即可，以下演示只是为让大家掌握另外一种安装方法。 以下操作在192.168.20.233服务器上进行。

1、JDK安装包获取

（1）进入甲骨文官网下载。

https://www.oracle.com/

 

  （2）下载自己需要安装的JDK版本，如下图所示：

  （3）找到JAVA 8对应的Linux版本下载即可，如下图所示：

（4）点击进行下载，需要登录甲骨文账号下载，自己注册一个登录

2、下载好JDK安装包后，上传安装服务器

我这里如下所示：

3、我这里打算将JDK安装在/usr/local目录下,将JDK安装包解压缩到安装目录下即可，大家根据自己实际环境执行解压命令。

 

tar -xzvf /ruanjianfile/jdk-8u381-linux-x64.tar.gz -C /usr/local/

  4、设置环境变量，通过修改/etc/profile文件进行设置。

vi /etc/profile

  通过编辑器打开编辑，文件最后加上如下内容保存。

export JAVA_HOME=/usr/local/jdk1.8.0_381
export PATH=$PATH:$JAVA_HOME/bin

  5、使环境变量生效，执行以下命令：

source /etc/profile

6、验证JDK是否安装成功。

java -version

  执行以上命令，出现如图所示，说明JDK成功安装。

 

  六、Jenkins安装部署

以下操作在192.168.20.232服务器上完成。

（一）Jenkins下载

1、官方下载地址

 

http://jenkins-ci.org/ 
或 
https://mirrors.jenkins-ci.org/redhat/

 

2、清华官方镜像站

 

https://mirrors.tuna.tsinghua.edu.cn/jenkins/redhat-stable/

 

3、我这里下载jenkins-2.414.1-1.1.noarch.rpm版本

高版本jenkins对JDK运行环境有要求，所以我安装了JDK11，JDK8好像出错。大家注意。

（二）Jenkins安装部署

1、下载好后上传192.168.20.232服务器目录

 

[root@node1 ruanjianfile]# ll
总用量 254160
drwxr-xr-x.  3 root  root         26 2月  24 2022 boost
-rw-r--r--.  1 root  root  139273048 7月  31 11:02 jdk-8u381-linux-x64.tar.gz
-rw-r--r--.  1 root  root   90991760 7月  31 14:21 jenkins-2.414.1-1.1.noarch.rpm
-rw-r--r--.  1 root  root   10368103 7月  19 17:21 node_exporter-1.6.1.linux-amd64.tar.gz
drwxr-xr-x. 17 mysql mysql      4096 7月  27 16:44 Python-3.10.9
-rw-r--r--.  1 root  root   19612112 12月  7 2022 Python-3.10.9.tar.xz

 

2、执行安装命令

 

rpm -ivh jenkins-2.414.1-1.1.noarch.rpm

 

3、查看Jenkins的安装信息

 

[root@node1 ruanjianfile]# rpm -ql jenkins
/etc/init.d/jenkins
/etc/logrotate.d/jenkins
/etc/sysconfig/jenkins
/usr/bin/jenkins
/usr/lib/systemd/system/jenkins.service
/usr/sbin/rcjenkins
/usr/share/java/jenkins.war
/usr/share/jenkins
/usr/share/jenkins/migrate
/var/cache/jenkins
/var/lib/jenkins
/var/log/jenkins
[root@node1 ruanjianfile]#

其中相关信息如下：

/etc/init.d/jenkins         #启动服务
/etc/logrotate.d/jenkins    #日志滚动目录
/etc/sysconfig/jenkins      #配置文件
/usr/bin/jenkins            #库文件目录

（三）修改Jenkins的配置文件

 

1、先备份原配置文件/etc/sysconfig/jenkins

2、修改配置文件，修改后内容如下：

 

[root@node1 sysconfig]# cat /etc/sysconfig/jenkins
主要修改以下内容：


JENKINS_HOME="/var/lib/jenkins"#jenkins工作目录
#JENKINS_USER="jenkins"
JENKINS_USER="root"#jenkins的启动用户
JENKINS_PORT="8080"#jenkins服务监听端口

 

（四）修改Jenkins的启动文件

1、先备份原启动文件/etc/init.d/jenkins 

2、修改配置文件

找到candidates=，在第一行加入jdk的路径，我这里通过yum安装的JDK11路径如下：

 

/usr/lib/jvm/java-11-openjdk-11.0.20.0.8-1.el7_9.x86_64

 

修改后内容如下：

 

# see http://www.nabble.com/guinea-pigs-wanted-----Hudson-RPM-for-RedHat-Linux-td25673707.html
candidates="
/usr/lib/jvm/java-11-openjdk-11.0.20.0.8-1.el7_9.x86_64
/etc/alternatives/java
/usr/lib/jvm/java-1.8.0/bin/java
/usr/lib/jvm/jre-1.8.0/bin/java
/usr/lib/jvm/java-11.0/bin/java
/usr/lib/jvm/jre-11.0/bin/java
/usr/lib/jvm/java-11-openjdk-amd64
/usr/bin/java
"

（五）启动Jenkins服务

1、启动Jenkins服务并且加到开机启动项

systemctl daemon-reload

systemctl start jenkins

[root@node1 bin]# systemctl status jenkins.service
● jenkins.service - Jenkins Continuous Integration Server
   Loaded: loaded (/usr/lib/systemd/system/jenkins.service; disabled; vendor preset: disabled)
   Active: active (running) since 四 2023-09-14 1755 CST; 4min 9s ago
 Main PID: 10950 (java)
   CGroup: /system.slice/jenkins.service
           └─10950 /usr/bin/java -Djava.awt.headless=true -jar /usr/share/java/jenkins.war --webroot=%C/jenkins/war --httpPort=8080


9月 14 1730 node1 jenkins[10950]: c47f2adc1add403d86b1c6e0bbc4d9e2
9月 14 1730 node1 jenkins[10950]: This may also be found at: /var/lib/jenkins/secrets/initialAdminPassword
9月 14 1730 node1 jenkins[10950]: *************************************************************
9月 14 1730 node1 jenkins[10950]: *************************************************************
9月 14 1730 node1 jenkins[10950]: *************************************************************
9月 14 1755 node1 jenkins[10950]: 2023-09-14 0955.702+0000 [id=31]        INFO        jenkins.InitReactorRunner$1#onAttained: Completed initialization
9月 14 1755 node1 jenkins[10950]: 2023-09-14 0955.733+0000 [id=23]        INFO        hudson.lifecycle.Lifecycle#onReady: Jenkins is fully up and running
9月 14 1755 node1 systemd[1]: Started Jenkins Continuous Integration Server.
9月 14 1757 node1 jenkins[10950]: 2023-09-14 0957.039+0000 [id=51]        INFO        h.m.DownloadService$Downloadable#load: Obtained the updated data file for hudso...venInstaller
9月 14 1757 node1 jenkins[10950]: 2023-09-14 0957.041+0000 [id=51]        INFO        hudson.util.Retrier#start: Performed the action check updates server successful...e attempt #1
Hint: Some lines were ellipsized, use -l to show in full.
[root@node1 bin]#

 

如果出现启动失败情况，检查各个配置文件信息是否一致。

（六）Jenkins登录配置

1、打开浏览器，输入http://服务器IP:8080网址，如我自己的：

 

http://192.168.20.232:8080/

 

正常可以看到如下页面：

2、根据上一个步骤提示，查询密码，然后输入，继续

 

[root@node1 ~]# cat /var/lib/jenkins/secrets/initialAdminPassword
1322f32fe3e646f1b0d058fa05372f43
[root@node1 ~]#

 

3、安装推荐插件

5、根据提示信息，创建管理员用户：

  我自己配置： 输入用户：haodaolinux，密码：haodao123，邮箱：[e-mail]等信息。 点击保存并完成。

6、实例配置

Jenkins URL 用于给各种Jenkins资源提供绝对路径链接的根地址。这意味着对于很多Jenkins特色是需要正确设置的，例如：邮件通知、PR状态更新以及提供给构建步骤的 BUILD_URL环境变量。推荐的默认值显示在尚未保存，如果可能的话这是根据当前请求生成的。最佳实践是要设置这个值，用户可能会需要用到。这将会避免在分享或者查看链接时的困惑。

点击“保存并完成”

7、完成配置

8、至此， jenkins部署完成，点击开始使用 jenkins，进入主界面。

（七）更改Jenkins插件地址为国内源地址

1、登录Jenkins进行配置

进入 Manage Jenkins =>>>Plugin=>>>高级， 最下面有 升级站点，设置为如下国内源地址：

 

https://mirrors.tuna.tsinghua.edu.cn/jenkins/updates/update-center.json

或

http://mirror.xmission.com/jenkins/updates/update-center.json

 

 

按如上替换配置后，点击提交进行修改。

2、修改Jenkins服务默认配置信息

进入 jenkins安装目录 下的/var/lib/jenkins/updates/default.json

将其中的updates.jenkins-ci.org/download 替换为 mirrors.tuna.tsinghua.edu.cn/jenkins

有些jenkins版本当中，

是将updates.jenkins.io/download替换为 mirrors.tuna.tsinghua.edu.cn/jenkins

然后，把www.google.com 修改为 www.baidu.com

我这个版本通过如下命令进行替换：

 

sed -i 's/https://updates.jenkins.io/download/https://mirrors.tuna.tsinghua.edu.cn/jenkins/g' default.json 
sed -i 's/https://www.google.com/https://www.baidu.com/g' default.json

  或

sed -i 's/http://updates.jenkins-ci.org/download/https://mirrors.tuna.tsinghua.edu.cn/jenkins/g' default.json && sed -i 's/http://www.google.com/https://www.baidu.com/g' default.json

 

3、完成以上步骤后，重启Jenkins服务,即可完成更新。

（八）卸载Jenkins操作

这里也附上Jenkins卸载相关操作，本实验我们无需操作！！！

 

# rpm卸载
rpm -e jenkins
# 检查是否卸载成功
rpm -ql jenkins
# 彻底删除残留文件
find / -iname jenkins | xargs -n 1000 rm -rf

 

 

删除残留文件

 

rm -rf /etc/sysconfig/jenkins.rpmsave
rm -rf /var/cache/jenkins/
rm -rf /var/lib/jenkins/
rm -rf /var/log/jenkins
rm -rf /usr/lib/jenkins

七、Jenkins相关概念

 

想要学习Jenkins相关功能，必须先要了解其相关概念

（一）持续集成

持续集成（Continuous Integration）：持续集成是一种软件开发实践，通过频繁地将代码集成到共享的代码仓库中，以及自动化构建和测试代码，确保团队的代码始终保持可靠和可部署。

（二）构建

构建（Build）：构建是指将源代码转化为可执行的软件或可部署的包的过程。Jenkins提供了构建工具和插件，可以执行各种构建任务，如编译代码、运行测试、生成文档等。

（三）任务

任务（Job）：任务是Jenkins中的基本单元，用于定义和管理构建过程。每个任务都有一组配置，包括源代码的位置、构建触发器、构建脚本等。

（四）触发器

触发器（Trigger）：触发器是用于触发构建过程的机制。Jenkins提供了多种触发器，如定时触发器（按照预定时间间隔触发构建）、代码提交触发器（当代码提交到版本控制系统时触发构建）等。 （五）插件

插件（Plugin）：Jenkins的功能可以通过插件进行扩展。插件可以用于添加新的构建工具、测试框架、通知方式等。Jenkins有大量的插件可供选择，并且可以自定义开发插件以满足特定需求。

（六）工作空间

workspace(工作空间)：jenkins是通过文件形式来存储和管理数据的。workspace即给jenkins指定一个专门的目录用来存储其所有的配置和数据。每个job的workspace当中是用来存放本任务涉及到的数据和文件，以及任务执行完成后生成的数据和文件。这就相当于每一个job开辟了一个独立的文件夹。

（七）流水线

流水线（Pipeline）：流水线是Jenkins的核心概念之一，用于定义和管理整个软件交付过程。流水线可以通过编写脚本来描述构建、测试和部署的各个阶段，并且可以通过图形化界面进行可视化和管理。

（八）构建代理

构建代理（Build Agent）：构建代理是Jenkins用于执行构建任务的工作节点。可以在不同的操作系统、硬件环境上配置多个构建代理，以提高构建的并发性和性能。

（九）测试

测试（Testing）：Jenkins提供了丰富的测试工具和插件，可以自动运行各种测试，如单元测试、集成测试、端到端测试等。测试结果可以通过Jenkins进行报告和分析。

（十）部署

部署（Deployment）：Jenkins可以与各种部署工具和云平台集成，实现自动化部署和发布软件的能力。可以将构建好的软件包或容器映像部署到目标环境中。

（十一）Jenkins用户权限管理

利用Role-based Authorization Strategy 插件来管理Jenkins用户权限。

1、安装Role-based Authorization Strategy 插件

（1）开启权限全局安全配置

（2）授权策略改为Role-Based Strategy

2、创建角色

（1）在Manage Jenkins管理界面找到 Manage and Assign Roles

（2）添加管理角色

Global roles：全局角色，主要用于配置用户的功能权限；

Item roles：项目角色，主要管理项目的权限。 这里我添加如下4个角色：

  Dev_Role和Test_Role：该角色为全局角色。这个角色需要绑定Overall下面的Read权限，是为了给所有用户定最基本的Jenkins访问权限。注意：如果不给后续用户绑定这个角色，会报错误：用户名 is missing the Overall/Read permission Role1：该角色为项目角色。使用正则表达式绑定"python.*"，意思是只能操作python开头的项目。 Role2：该角色也为项目角色。绑定"linux.*"，意思是只能操作linux开头的项目。

3、新建用户

（1）在Manage Jenkins管理界面找到Users  

这里创建3个账号： huanghao hh123456 lipython hh123456 zhanglinux hh123456

（2）新建用户绑定对应角色

4、创建测试项目

创建linux01和python01两个项目；

通过登录lipython账号，只能看到python01项目信息； 通过登录zhanglinux，只能看到linux01项目信息；

（十二）Jenkins凭证管理

凭证可以用来存储需要密文保护的数据库密码、Gitlab密码信息、Docker私有仓库密码等，以便Jenkins可以和这些第三方的应用进行交互。

1、安装Credentials Binding插件

2、凭证类型（用户密码类型）

（1）创建凭证

选择"Username with password"，输入Gitlab的用户名和密码，点击"Create"。

（2）测试凭证是否生效

1）新建一个FreeStyle项目：新建Item->FreeStyle Project->确定

2）找到"源码管理"->"Git"，在Repository URL复制Gitlab中的项目URL

3）保存配置后，点击构建”Build Now“ 开始构建项目

4）控制台输出可以看到构建成功

5）查看/var/lib/jenkins/workspace/目录，发现已经从Gitlab成功拉取了代码到Jenkins中。

3、凭证类型（SSH秘钥类型）

（1）创建凭证

1）SSH免密登录拓扑如下所示：

2）Jenkins对应服务器上登录root，生成公钥和私钥

 

ssh-keygen -t rsa

 

执行上述命令后，然后敲（四个回车），对应/root/.ssh就会生成两个文件id_rsa（私钥）、id_rsa.pub（公钥），如下图所示：

其中

id_rsa：私钥文件 id_rsa.pub：公钥文件

3）将公钥内容复制到gitlab，以root账户登录->点击头像->Edit profile->SSH Keys，如下图所示：

4）Jenkins中创建凭证，选择SSH Username with private key

（2）测试凭证是否生效

1）新建"linux-web02"项目->源码管理->Git，这次要使用Gitlab的SSH连接，并且选择SSH凭证。

注意：如果出现类似stderr: No ECDSA host key is known for 192.168.20.231 and you have requested这样的报错信息。 但是在jenkins服务器上手动执行拉取命令又可以正常的，可以根据以下排查解决。 手动拉取测试正常，命令如下：

 

git clone git@192.168.20.231:haodaolinux_group/web_demo.git

 

 

针对以上报错解决方法：

这是因为ssh连接陌生机器需要确认，将jenkins器上的known_hosts复制到运行jenkins服务账号的～/.ssh目录下即可。

 

[root@node1 .ssh]# ps aux | grep jenkins
jenkins   6799  0.3 46.0 4376136 863264 ?      Ssl  10月07   8:32 /usr/bin/java -Djava.awt.headless=true -jar /usr/share/java/jenkins.war --webroot=%C/jenkins/war --httpPort=8080
root      8767  0.0  0.0 112824   988 pts/0    R+   08:58   0:00 grep --color=auto jenkins
[root@node1 .ssh]# cat /etc/passwd | grep jenkins
jenkins997:995:Jenkins Automation Server:/var/lib/jenkins:/bin/false

 

以上命令可以看到运行jenkins服务的账号为jenkins，其home为/var/lib/jenkins

即执行以下命令复制相关文件

 

cp /root/.ssh/known_hosts /var/lib/jenkins/.ssh/

  3）保存配置后，点击构建”Build Now“ 开始构建项目

4）控制台输出可以看到构建成功

 

5）查看/var/lib/jenkins/workspace/目录，发现已经从Gitlab成功拉取了代码到Jenkins中。

  八、Maven安装部署 以下操作在192.168.20.232服务器上完成。

（一）maven简介

maven最主要体现在两个词上：项目和管理。maven给我们整个开发团队找出了一种能够更加科学的去管理我们项目的思想。maven通过使用配置文件的方式使得项目在管理和交接的过程中成本变得非常低。maven提出了一种叫做maven仓库的概念，使得我们可以将第三方和我们需要引用的项目都放置在maven仓库当中。如果其他人或项目组也需要使用,就可以直接通过maven进行配置就行。这样就可以将人员成本、沟通成本等等都进行降低。

如果还不理解，我们举个通俗例子：假如我们现在想做一道菜：广西扣肉。如果我们想要做这道菜，那么我们首先要先去菜市场买猪肉、芋头、酱料等、......，而且在做的时候还要注意使用猪肉的用量等等。此时如果有一个超市，该超市有卖猪肉、芋头、酱料等食材，这是不是就能很大的节省我们做扣肉和买材料的时间开销。其实maven就是这个卖食材的超市，当然卖的不是各种食材，而是一系列的jar包。这样我们在写代码的时候就不需要去其他网站上下载一大堆的jar包。

（二）Maven下载地址

1、官网下载地址

 

https://maven.apache.org/download.cgi

  2、清华大学镜像源地址

https://mirrors.tuna.tsinghua.edu.cn/apache/maven/maven-3

 

（三）Maven安装

我这里下载安装3.9.5版本，通过wget命令下载到本地。

 

wget https://mirrors.tuna.tsinghua.edu.cn/apache/maven/maven-3/3.9.5/binaries/apache-maven-3.9.5-bin.tar.gz --no-check-certificate

 

1、创建安装目录

 

mkdir -p /opt/maven

 

2、将maven压缩包解压

 

tar -zxvf apache-maven-3.9.5-bin.tar.gz

 

3、将解压后的相关maven文件移动到/opt/maven目录下

 

mv apache-maven-3.9.5/* /opt/maven/

 

4、配置环境变量，编辑/etc/profile文件，添加如下配置；

 

export MAVEN_HOME=/opt/maven
export PATH=$PATH:$MAVEN_HOME/bin

 

5、使配置文件生效

 

source /etc/profile

 

6、验证maven是否安装成功，看到如下信息说明安装成功；

 

[root@node1 ~]# mvn -v
Apache Maven 3.9.5 (57804ffe001d7215b5e7bcb531cf83df38f93546)
Maven home: /opt/maven
Java version: 1.8.0_381, vendor: Oracle Corporation, runtime: /usr/local/jdk1.8.0_381/jre
Default locale: zh_CN, platform encoding: UTF-8
OS name: "linux", version: "3.10.0-957.el7.x86_64", arch: "amd64", family: "unix"
[root@node1 ~]#

 

（四）Jenkins中配置关联JDK和Maven

1、打开Manage Jenkins---Tools，找到JDK，新增JDK。根据自己JDK实际环境配置添加即可，如下图所示：

2、打开Manage Jenkins---Tools，找到Maven，新增Maven。根据自己Maven实际环境配置添加即可，如下图所示：

3、按照上述配置，应用保存即可。

（五）添加Jenkins全局变量

1、打开Manage Jenkins---System Configuration，找到System，找到全局属性，勾选Environment variables，点击新增，添加JAVA_HOME、MAVEN_HOME、PATH+EXTRA三个全局变量，填写相关键值，我添加如下所示：

（六）修改Maven的配置文件settings.xml

1、修改本地下载仓库为/root/maven_repo，配置如下所示：

 

/root/maven_repo

 

2、注释默认的镜像地址，添加阿里云镜像地址，配置如下所示：

 

     alimaven
     aliyun maven
     http://maven.aliyun.com/nexus/content/groups/public/
     central

 

3、验证maven配置是否成功。

我这里新建一个web项目进行测试。

（1）项目配置如下：

（2）再次构建时，可以成功打包成war包，控制台输出如下：

注意事项1：有的构建时会出错，那得看输出日志信息进行排查，一般是IDEA建立WEB项目时，pom.xml语法有错误，我这里修改该文件主要是用于编译成war包，大概如下，可以参考29-49行。

 

    4.0.0


    com.example
    test
    1.0-SNAPSHOT
    test


    
        UTF-8
        1.8
        1.8
        5.8.1
    


    


        
            org.junit.jupiter
            junit-jupiter-api
            ${junit.version}
            test
        
    


    
        


            
                org.apache.maven.plugins
                maven-war-plugin
                3.3.2
                
                    web/WEB-INF/web.xml
                
                
                    
                        package
                        
                        war
                        
                    
                
            
        
    

  注意事项2：maven运行JDK与Jenkins运行的JDK环境版本保持一致。  

 

maven中settings.xml配置文件针对JDK版本指定

九、Tomcat安装部署

以下操作在192.168.20.233服务器上完成。

（一）Tomcat安装

tomcat运行需要JDK环境支持，所以以下步骤基于已经安装好JDK基础上进行。服务器相关防火墙已经关闭。

1、tomcat下载

可以直接通过tomcat官方网站下载对应版本地址，官方地址如下：

 

https://archive.apache.org

 

2、我这里下载的版本是apache-tomcat-9.0.58.tar.gz，可以通过以下链接进行下载。

 

wget https://archive.apache.org/dist/tomcat/tomcat-9/v9.0.58/bin/apache-tomcat-9.0.58.tar.gz

 

3、创建tomcat安装目录

 

mkdir /opt/tomcat

 

4、解压源码

 

tar -xzvf apache-tomcat-9.0.58.tar.gz

 

5、移动解压后相关文件到安装目录下

 

mv /ruanjianfile/apache-tomcat-9.0.58/* /opt/tomcat/

 

6、启动tomcat

 

/opt/tomcat/bin/startup.sh

 

7、通过浏览器访问如下地址，可以正常打开如下界面，说明tomcat安装成功。

 

http://192.168.20.233:8080/

 

  8、配置tomcat用户角色权限

因为Jenkins部署项目到Tomcat服务器，需要用到Tomcat的用户，所以修改tomcat以下配置，添加用户及权限。 编辑/opt/tomcat/conf/tomcat-users.xml文件，添加如下内容：

 

 

用户和密码都是：tomcat

9、修改配置文件，让tomcat用户可以登录到tomcat服务器。

配置文件路径如下：

 

/opt/tomcat/webapps/manager/META-INF/context.xml

  注释如下内容即可。

 

10、重启tomcat服务

 

/opt/tomcat/bin/shutdown.sh
/opt/tomcat/bin/startup.sh 

 

11、访问以下地址进行测试，针对上述的配置是否已经生效。

 

http://192.168.20.233:8080/manager/html

 

提示需要登录用户名及密码，填写tomcat,tomcat

打开到如下界面说明配置成功。

十、IDEA中创建WEB项目

好多朋友不是做开发的，对IDEA使用比较陌生，在此也给大家演示如何在IDEA下创建WEB项目进行后面的实验。这里主要是模拟开发角色进行往下的实验。可以是你的物理主机上操作。

（一）IDEA安装

大家可以自己网上找相关的安装包进行安装即可。我以下基于IntelliJ IDEA 2021.3.2 (Ultimate Edition)进行操作。

（二）IDEA中创建WEB项目

1、新建项目

（1）新建一个项目，如下图所示：

（2）点击Next，如下图所示：

（3）点击Finish完成项目建立，如下所示：

2、配置项目的tomcat环境

（1）选择file—>>project structure

（2）选中project ，配置jdk和编译输入目录，如下图所示：

（3）选中libraries，配置依赖jar包，如下图所示：

选择自己环境的tomcat安装包目录，如下：

（4）选中modules，配置工程架构，点击 + —Web

选中WEB，位于下方的Deployment Descriptors中，点击“+”，选择web工程中的web.xml文件。

下方的Web Resource Directories中，是配置资源文件的所在目录的，点击“铅笔”，选择到Web目录。配置完成后点击Apply

（5）选中artifacts配置   点击 + — Web Application:Exploded — From Modules

  此时建立了工程的部署WAR包

3、将工程部署在web容器中

（1）点击Run — Edit Configurations菜单进入配置页面

  （2）点击 + — Tomcat Server --> Local，进入Tomcat配置页面

  （3）选中Deployment配置   点击 + — Artifact，选择前面配置好的WAR包

  （4）选中server配置   可配置tomcat容器的名称，启动后打开的浏览器，tomcat的端口，修改代码后是否热部署，以及配置虚拟机的启动参数等等。

到此，一个Web工程创建及配置已完成，可启动tomcat，启动工程环境。

4、项目测试

（1）选择项目中web，右键新建jsp。

填写名字后按下回车键即可。

index.jsp创建如下代码，用于测试页面展示：

 

<%--
  Created by IntelliJ IDEA.
  User: huanghao
  Date: 2023/10/11
  Time: 19:08
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>

    
        
    
    
    浩道的项目部署成功了！！！
    

  （2）右键，选择Run index.jsp

 

出现如下界面说明项目跑成功。

如果跑不成功，说明URL配置不对，可以返回点击Run — Edit Configurations菜单进入配置页面重新配置，如下所示即可：

十一、Jenkins项目构建

Jenkins中自动构建项目的类型有很多，常用的有以下三种： 自由风格软件项目（FreeStyle Project） Maven项目（Maven Project） 流水线项目（Pipeline Project） 每种类型的构建其实都可以完成一样的构建过程与结果，只是在操作方式、灵活度等方面有所区别，在实际开发中可以根据自己的需求和习惯来选择。

（一）Jenkins下构建自由风格软件项目

以下演示的Jenkins构建自由风格软件项目，实现项目代码拉取，项目代码编译，项目打包，项目部署的集成化过程。

1、创建自由风格软件项目

2、针对新建项目，配置源码管理，用于从gitlab仓库中拉取项目源码，我这里配置如下：

3、添加构建步骤，用于编译打包

 

echo "开始编译和打包。。。"
mvn clean packageecho 
"编译和打包结束！！！"

 

  4、项目部署

这里主要是将编译打包好的war包部署到远程服务器上的tomcat中，让项目服务跑起来。

（1）安装 Deploy to container插件   Jenkins提供Deploy to container插件，用于实现远程部署到Tomcat的功能。

（2）添加tomcat用户凭证，用户名及密码都是tomcat

  （3）添加项目构建后操作内容

（4）开始构建，通过控制台输出日志，已经构建，编译打包，部署成功。

打开部署后的tomcat，可以看到如下页面，说明成功了！

  （5）修改index.jsp代码后，提交gitlab仓库，再次构建，打开tomcat，如下所示：  

注意，项目中的pom.xml文件，我这里大概内容如下：

 

    4.0.0


    com.example
    WebJenkinsDemo01
    1.0-SNAPSHOT
    WebJenkinsDemo01
    war


    
        UTF-8
        1.8
        1.8
        5.8.1
    


    


        
            org.junit.jupiter
            junit-jupiter-api
            ${junit.version}
            test
        
        
            org.junit.jupiter
            junit-jupiter-engine
            ${junit.version}
            test
        
    


    
        
            
                org.apache.maven.plugins
                maven-war-plugin
                3.3.2


                
                    webWEB-INFweb.xml
                    web
                


 
                            
                        
                    
                

 

（二）Jenkins构建maven项目

构建maven项目需要相关安装插件。

1、安装Maven Integration插件

2、创建Maven项目

3、配置项目

（1）配置拉取代码

  （2）配置远程部署

（3）配置构建

4、测试构建项目

（1）可以看到控制台日志输出显示成功。

（2）打开tomcat，可以看到是我自己部署的项目页面；

注意：这里可能会有不同版本jenkins，Maven等差异，需要的JDK环境不一样导致构建失败，可以通过日志看出，一开始我用JDK8构建失败，改成JDK11后构建成功！！！

（三）Jenkins构建Pipeline流水线项目

1、Pipeline介绍

Pipeline，简单来说，就是一套运行在 Jenkins 上的工作流框架，将原来独立运行于单个或者多个节点的任务连接起来，实现单个任务难以完成的复杂流程编排和可视化的工作。

2、Pipeline构建项目好处

官方文档是这样列举的： 代码：Pipeline以代码的形式实现，通常被检入源代码控制，使团队能够编辑，审查和迭代其传送流程。 持久：无论是计划内的还是计划外的服务器重启，Pipeline都是可恢复的。 可停止：Pipeline可接收交互式输入，以确定是否继续执行Pipeline。 多功能：Pipeline支持现实世界中复杂的持续交付要求。它支持fork/join、循环执行，并行执行任务的功能。 可扩展：Pipeline插件支持其DSL的自定义扩展 ，以及与其他插件集成的多个选项。

3、怎样创建Pipeline项目

Pipeline 脚本是由 Groovy 语言实现的，但是我们没必要单独去学习 Groovy； Pipeline 支持两种语法：Declarative(声明式)和 Scripted Pipeline(脚本式)语法； Pipeline 也有两种创建方法：可以直接在 Jenkins 的 Web UI 界面中输入脚本；也可以通过创建一个 Jenkinsfile 脚本文件放入项目源码库中（一般我们都推荐在 Jenkins 中直接从源代码控制(SCM)中直接载入 Jenkinsfile Pipeline 这种方法）。 需要安装Pipeline插件；

4、Pipeline语法入门（声明式）

（1）安装pipeline插件

（2）创建Pipeline流水线项目

（3）找到---流水线---选择Hello World模板

选择Hello World模板后，生成脚本内容如下：

stages：代表整个流水线的所有执行阶段。通常stages只有1个，里面包含多个stage

stage：代表流水线中的某个阶段，可能出现n个。一般分为拉取代码，编译构建，部署等阶段。

steps：代表一个阶段内需要执行的逻辑。steps里面是shell脚本，git拉取代码，ssh远程发布等任意内容。

（4）如下我编写一个简单声明式Pipeline：

 

pipeline {
    agent any


    stages {
        stage('项目代码拉取') {
            steps {
                echo '项目代码拉取中。。。'
            }
        }
        
        stage('项目代码编译构建') {
            steps {
                echo '项目代码编译构建中。。。'
            }
        }
        
        stage('项目代码部署') {
            steps {
                echo '项目代码部署中。。。'
            }
        }
    }
}

 

 

  （5）应用保存，点击构建项目，控制台日志输出可以看到构建成功。

5、Pipeline语法入门（脚本式）

（1）创建Pipeline流水式项目

（2）找到---流水线---选择Scripted Pipeline模板

生成如下脚本信息

Node：节点，一个 Node 就是一个 Jenkins 节点，Master 或者 Agent，是执行 Step 的具体运行 环境，后续讲到Jenkins的Master-Slave架构的时候用到。

Stage：阶段，一个 Pipeline 可以划分为若干个 Stage，每个 Stage 代表一组操作，比如：Build、Test、Deploy，Stage 是一个逻辑分组的概念。

Step：步骤，Step 是最基本的操作单元，可以是打印一句话，也可以是构建一个 Docker 镜像， 由各类 Jenkins 插件提供，比如命令：sh ‘make’，就相当于我们平时 shell 终端中执行 make 命令一样。 如下编写一个简单的脚本式Pipeline：

 

node {
    def mvnHome
    stage('项目代码拉取') {
        echo '项目代码拉取中。。。'
    }
    stage('项目代码编译构建') {
       
        echo '项目代码编译构建中。。。'
    }
    stage('项目代码部署') {
        echo '项目代码部署中。。。'
    }
}

 

 

（3）点击应用保存，构建项目，可以看到构建成功。

6、Pipeline语法拉取代码（声明式）--脚本在UI中编辑

（1）构建Pipeline流水线项目linux-web-pipeline03

  （2）找到---流水线---选择Hello World模板，编辑脚本，这里主要编辑项目代码拉取、编译、构建这三个步骤对应操作代码。通过下方的流水线语法自动完成代码构建。

（3）生成代码拉取脚本，找到代码片段生成器，示例步骤中选择checkout相关插件，填写需要拉取的代码Git仓库地址，认证信息，下方点击生成流水线脚本即可生成相关代码，复制到上述脚本中对应拉取代码步骤即可，如下图所示：

（4）生成项目代码编译构建脚本，找到代码片段生成器，示例步骤中选择sh:Shell Script相关插件，填写需要执行的shell命令脚本，下方点击生成流水线脚本即可生成相关代码，复制到上述脚本中对应项目代码编译构建步骤即可，如下图所示：

（5）生成项目代码部署脚本，找到代码片段生成器，示例步骤中选择deployt相关插件，填写tomcat容器相关信息，下方点击生成流水线脚本即可生成相关代码，复制到上述脚本中对应项目代码部署步骤即可，如下图所示：

（6）生成对应步骤脚本后，完整脚本如下：

 

pipeline {
    agent any


    stages {
        stage('项目代码拉取') {
            steps {
                checkout scmGit(branches: [[name: '*/master']], extensions: [], userRemoteConfigs: [[credentialsId: 'b3751cd7-e1eb-46c1-8939-dffda217db4d', url: 'git@192.168.20.231:haodaolinux_group/haodao_web.git']])
            }
        }
        stage('项目代码编译构建') {
            steps {
                sh 'mvn clean package'
            }
        }
        stage('项目代码部署') {
            steps {
                deploy adapters: [tomcat9(credentialsId: '3b209a0d-bf85-4d53-8096-a5c926b09377', path: '', url: 'http://192.168.20.233:8080/')], contextPath: null, war: 'target/*.war'
            }
        }
    }
}

 

（7）点击应用保存配置，构建，可以看到成功了

7、Pipeline语法拉取代码（声明式）--脚本在java项目中

（1）IDEA中对应项目根目录创建HaodaoWebJenkinsFile文件，将UI中对应声明式脚本复制粘贴过来

 

pipeline {
    agent any


    stages {
        stage('项目代码拉取') {
            steps {
                checkout scmGit(branches: [[name: '*/master']], extensions: [], userRemoteConfigs: [[credentialsId: 'b3751cd7-e1eb-46c1-8939-dffda217db4d', url: 'git@192.168.20.231:haodaolinux_group/haodao_web.git']])
            }
        }
        stage('项目代码编译构建') {
            steps {
                sh 'mvn clean package'
            }
        }
        stage('项目代码部署') {
            steps {
                deploy adapters: [tomcat9(credentialsId: '3b209a0d-bf85-4d53-8096-a5c926b09377', path: '', url: 'http://192.168.20.233:8080/')], contextPath: null, war: 'target/*.war'
            }
        }
    }
}

 

（2）创建Pipeline流水式项目,命名linux-web-pipeline04

（3）找到---流水线---选择Pipeline script from SCM，编辑代码远程仓库URL，选择脚本路径，如下图所示：

（4）点击应用保存配置，构建，可以看到成功了。

十二、Jenkins构建项目技巧

通过以上步骤，我们已经可以针对Jenkins项目进行整个构建流程的跑通。但是我们可以继续利用构建项目的一些技巧，让Jenkins构建项目变得更加高效，如通过触发器构建项目。以下就针对这些构建技巧一一展开。

（一）Jenkins常见触发器

Jenkins内置了4种构建触发器：

触发远程构建 其他工程构建后触发（Build after other projects are build） 定时构建（Build periodically） 轮询SCM（Poll SCM） 以下针对这4钟构建触发器分别举例实践说明。

1、触发远程构建

（1）以下仅仅验证触发器功能，可以在原有已经创建项目的基础是修改配置进行测试；

（2）对项目进行配置，找到“构建触发器”，选择“触发远程构建”，添加“身份验证令牌”，描述下方有对应的触发器链接，用浏览器打开对应格式的链接即可触发远程构建动作，如下图所示：

（3）应用保存配置，现在该项目已经有了一次构建记录，此时用浏览器打开如下链接，触发远程构建，看看会不会触发项目进行第二次构建。

 

 192.168.20.232:8080/job/linux-web-pipeline04/build?token=haodaolinux

（4）当浏览器打开上述链接后，项目已经触发第二次构建，即触发远程构建成功。

 

2、其它工程构建后触发

其它工程构建后触发，就说明涉及到另外一个工程，这里创建一个用于触发的工程，名称为linux-web-job

（1）创建一个名称为linux-web-job的自由风格项目，对该项目进行简单配置即可，如执行shell脚本操作，如下所示：

（3）对需要触发构建的工程进行配置，这里主要是配置构建触发器，找到“Build after other projects are built”，选择对应的触发工程linux-web-job，如下图所示：

（4）对linux-web-job工程进行构建，另外配置好的触发工程也会进行构建成功，如下所示：

3、定时构建触发

定时构建，见名知意，就是通过设定触发时间，让工程自动构建，这里的定时机制跟Linux系统下的定时任务语法差不多。通过5个*空格开，从左往右表示分，时，日，月，周，5个时间段。（1）以下通过实例简单讲解这些时间段表示方法。

1）每10分钟构建一次：H代表形参 H/10 * * * * ，这样09:00，09:10,09:20，...，按10分钟间隔有规律的构建；

2）每2个小时构建一次: H H/2 * * *

3）每天的9点，11点，20点，一天构建3次，(多个时间点中间用逗号隔开)：0 9,11,20 * * *

4）每天中午12点定时构建一次： H 12 * * *

5）每天下午20点定时构建一次： H 20 * * *

6）在每个小时的前半个小时内的每10分钟构建一次： H(0-29)/10 * * * *

7）每两小时一次，每个工作日上午9点到下午5点(也许是上午10:36，下午12:36，下午2:36，下午4:36)构建一次： H H(9-16)/2 * * 1-5

（2）以下对原来项目修改配置，让项目每隔2分钟构建一次，如下图所示：

（3）查看执行效果

4、轮询SCM触发

轮询SCM，是指Jenkins定时扫描本地代码仓库的代码是否有变更，如果代码有变更就触发项目构建。

但是这种方式有个弊端，那就是这个构建触发器，Jenkins会定时扫描本地整个项目的代码，增大了系统的开销，实际项目中是不建议使用的。 以下也针对这种触发方式做一个配置实验。 轮询SCM触发原理示意图如下：

（1）针对已有项目做轮询SCM触发配置。如下所示：

  以上配置表示每分钟去轮询代码是否有变更。  

（2）修改代码，提交远程仓库；

（3）待代码提交仓库后一会，项目会触发构建，并且成功。

5、Webhook自动触发

Webhook自动触发构建就是针对轮询SCM触发中存在性能不佳而改进的一种优化方案。该方案就是利用Gitlab的webhook实现代码push到仓库，立即触发项目自动构建。

Webhook自动触发原理示意图如下：

（1）Jenkins中安装Generic Webhook Trigger和GitLab两个插件。

（2）Jenkins中针对已有项目做Webhook触发配置。如下所示：

等会需要把生成的webhook URL：http://192.168.20.232:8080/project/linux-web-pipeline04配置到Gitlab中。

  （3）Gitlab配置webhook相关参数  

1）启用webhook功能 root账户登录到Gitlab后台，点击Admin Area -> Settings -> Network

2）在对应项目添加webhook 点击对应项目->Settings->Webhooks

（4）Jenkins中配置相关系统参数，Manage Jenkins->Configure System->System，修改配置如下：

  （5）修改代码，提交远程仓库；

（6）待代码提交仓库后一会，项目会触发构建，并且成功。

  十三、总结

到此，实验已经结合环境跑通整个自动化持续集成流程了。但是Jenkins本身功能众多，就不一一举例演示给大家了，诸如后续的一些功能，如配置邮箱服务器发送构建结果、结合SonarQube进行代码审查，以及基于Docker、K8S环境跑Jenkins持续集成，大家可以自行去研究，大体配置流程都差不多。

审核编辑：刘清