Jenkins 集成持续部署

一、CI/CD 的概念

CI/CD一般包含三个概念：持续集成（Continuous Integration ，CI），持续交付（Continuous Delivery），持续部署（Continuous Deploy）

CI/CD 是现代软件开发的重要流程，旨在提升软件开发与交付的效率、可靠性和质量

1.1 持续集成 (CI)

在传统软件开发过程中，集成通常发生在每个人都完成了各自的工作之后，所谓集成，可以理解为团队里的大家完成自己负责的模块后，将各个子模块集成为一个可以完成整体功能的完整模块。在项目尾声阶段，通常集成还要痛苦的花费数周或者数月的时间来完成。持续集成是一个将集成提前至开发周期的早期阶段的实践方式，让构建、测试和集成代码更经常反复地发生。

为了实现持续集成，我们每个人都需要做单元测试 (Unit Test)，以确保各个子模块的正常工作

关键点
- 代码合并到主分支时触发构建
- 自动化运行单元测试和集成测试
- 提供反馈给开发者
典型工具：Jenkins、GitLab CI/CD、Travis CI、CircleCI

1.2 持续交付

持续交付是持续集成的延伸，将集成后的代码部署到类生产环境，确保可以以可持续的方式快速向客户发布新的更改。我们把代码部署到测试环境，预发布环境等等类生产环境成为交付。

关键点：
- 部署到预生产环境后进行验证
- 保持一致的部署流程
典型工具：Spinnaker、ArgoCD、FluxCD

1.3 持续部署

如果真的想获得持续交付的好处，应该尽早部署到生产环境，以确保可以小批次发布，在发生问题时可以轻松排除故障。于是有了持续部署。

我们通常将这个在不同环境发布和测试的过程叫做部署流水线

持续部署是在持续交付的基础上，把部署到生产环境的过程自动化

1.4 DevOps

DevOps 是一种文化和方法论，旨在通过开发(Development)、测试(QA) 与运维(Operations) 团队的协作，提升软件开发、交付和运维的效率。它不仅关注技术工具，也关注团队协作和流程优化

虽然名字里没有体现，但是 DevOps 仍包括测试

DevOps 的好处：
- 提升发布速度：更频繁地交付高质量的软件
- 增强稳定性：通过自动化测试和监控减少生产问题
- 更高的协作效率：开发与运维团队共同承担责任
- 快速响应市场需求：支持小步快跑式的开发模式
CI/CD 与 DevOps 的关系

CI/CD 是 DevOps 实现中的关键实践之一。DevOps 更加关注文化、流程和工具的整合，而 CI/CD 则是通过自动化实现开发与运维目标的重要手段。两者结合能够显著提升软件开发与交付的效率和质量。

CI/CD 更关注的是整个开发，测试，部署的自动化的过程，当我们在本地单元测试通过后，我们提交到 git 上，触发相应的 webhook 或者类似的东西进行代码的构建，并打包部署到相应的机器上，自动化的完成这整个过程

而 DevOps 更关注的是打通用户、PMO、需求、设计、开发(Dev)、测试、运维(Ops) 等各上下游部门或不同角色；打通业务、架构、代码、测试、部署、监控、安全、性能等各领域工具链；尤其是打通开发与运维之间的 gap，因为两者实际上存在着很多的冲突。DevOps 是基于 CI/CD 的，自动化的流程是基础，DevOps 是一个项目由 idea 到实际稳定运行的产品的一个最佳实践

DevOps 是 CI/CD 思想的延伸，CI/CD 是 DevOps 的基础核心，如果没有 CI/CD 自动化的工具和流程，DevOps 是没有意义的

二、安装配置 Jenkins

服务器	IP
Jenkins	192.168.100.130
java	192.168.100.132

外加三个 Github 项目（两个共有仓库，一个私有仓库）

2.1 安装 Jenkins

配置环境和 Jenkins 官方的 yum 源之后进行安装

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


# 关闭防火墙
$ sudo systemctl stop firewalld
$ sudo systemctl disable firewalld

# 安装 EPEL 源
$ sudo yum install -y epel-release
# 安装 wget
$ sudo yum install -y wget

# 配置 Jenkins 官方 yum 源
$ sudo wget -O /etc/yum.repos.d/jenkins.repo https://pkg.jenkins.io/redhat-stable/jenkins.repo
$ sudo rpm --import https://pkg.jenkins.io/redhat-stable/jenkins.io-2023.key

# 安装所需环境
$ yum install -y https://download.oracle.com/java/21/latest/jdk-21_linux-x64_bin.rpm
$ yum install fontconfig daemonize -y
# 安装 Jenkins
$ yum install jenkins -y

然后启动 Jenkins

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


$ sudo systemctl start jenkins

# 查看 Jenkins 是否启动（8080端口是否监听）
$ sudo yum install -y net-tools
$ netstat -ntpl
激活Internet连接 (仅服务器)
Proto Recv-Q Send-Q Local Address           Foreign Address         State       PID/Program name    
tcp        0      0 127.0.0.1:631           0.0.0.0:*               LISTEN      1245/cupsd          
tcp        0      0 127.0.0.54:53           0.0.0.0:*               LISTEN      625/systemd-resolve 
tcp        0      0 127.0.0.53:53           0.0.0.0:*               LISTEN      625/systemd-resolve 
tcp6       0      0 :::8080                 :::*                    LISTEN      1246/java           
tcp6       0      0 ::1:631                 :::*                    LISTEN      1245/cupsd          
tcp6       0      0 :::22                   :::*                    LISTEN      1/init

然后访问 http://192.168.100.130:8080 来访问 Jenkins

2.1.1

然后查看密码，之后点击继续

1
2


$ cat /var/lib/jenkins/secrets/initialAdminPassword
972528bd9d594dca9cca7e0947be1d48

2.2 配置 Jenkins

登录之后，这里选择 “安装推荐的插件”，然后点击继续

2.1.2

稍微等待一会

2.1.3

稍微等待一会之后，就到了创建第一个管理员用户的页面

2.1.4

其余配置默认即可

2.1.5

2.1.6

2.2.1 安装插件

进来之后依次点击 “Manage Jenkins” → “Plugins”，在 “Installed plugins” 里面搜索 “Git plugin” 和 “Publish Over SSH” 两个插件

如果没有，就去 “Available plugins” 来进行搜索并安装

2.2.1.1

插件安装完成之后，重启 Jenkins

1

$ sudo systemctl restart jenkins

2.2.2 配置 Publish Over SSH

首先需要在服务器上 ~/.ssh 目录下生成一对密钥

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


$ cd ~/.ssh
$ ssh-keygen -t rsa

# 检验
$ ll ~/.ssh/
总计 28
drwx------ 2 root root 4096 12月 16 13:39 ./
drwx------ 5 root root 4096 12月 16 12:55 ../
-rw------- 1 root root  571 12月 16 09:09 authorized_keys
-rw------- 1 root root 2602 12月 16 09:01 id_rsa
-rw-r--r-- 1 root root  571 12月 16 09:01 id_rsa.pub

密钥生成成功之后，登录 Jenkins，点击 “Manage Jenkins” → “System” 往下翻找到 Key，然后把 id_rsa 文件的内容全部都复制进去

在两台服务器上都复制刚才生成的 ~/.ssh/id_rsa.pub 到 ~/.ssh/authorized_keys 里面，然后都尝试在 Jenkins 服务器上进行登录

尝试登录成功之后，登录 Jenkins，在 “Manage Jenkins” → “System” 下面添加两台 SSH Server，然后都点击 “Test Configuration” 来测试是否连接成功

2.2.2.1

3.3.1 2.2.2.2

2.2.3 构建新的任务

在 Dashboard 页面点击 “新建Item”

2.2.3.1

填写 “描述” 之后，下面的 “源码管理” 选择 “Git”，然后将代码仓库的地址填写到 “Repository URL” 里面

2.2.3.3

下面的 “构建触发器” 和 “构建环境” 保持默认即可

2.2.3.4

然后在 “Build Step” 下面的 “增加构建步骤” 里面选择 “Send files or execute commands over SSH”

2.2.3.5

然后在 Name 下面选择机器名称（两个都要配置）

2.2.3.6 3.3.2

然后点击 “高级” 其中的 “Pattern separator” 保持默认即可

然后进入任务，点击 “Build Now”(立即构建)，查看“控制台输出”，最后登陆机器查看代码是否成功发布

2.2.3.7

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


# Jenkins 机器上
$ ll /tmp/jenkins_test/
总计 24
drwxr-xr-x  2 root root 4096 12月 16 16:47 ./
drwxrwxrwt 21 root root 4096 12月 16 16:47 ../
-rw-r--r--  1 root root 9373 12月 16 16:47 just_a_sh_file
-rw-r--r--  1 root root  110 12月 16 16:47 README.md

# java 机器上
$ ll /tmp/test
总计 24
drwxr-xr-x  2 root root 4096 12月 16 16:47 ./
drwxrwxrwt 18 root root 4096 12月 16 16:47 ../
-rw-r--r--  1 root root 9373 12月 16 16:47 just_a_sh_file
-rw-r--r--  1 root root  110 12月 16 16:47 README.md

2.2.4 Jenkins 邮件配置

依次点击 “Manage Jenkins” → “System” 然后找到 “Jenkins Location” 下面填入“系统管理员邮箱地址”

2.2.4.1

找到 “邮件通知”，按照如下内容填写

此处的 “密码”，不是你那个邮箱平台的账号密码，而是SMTP登录密码，具体的获得方式请自行

2.2.4.2

然后点击 “通过发送测试邮件测试配置” 填上任意一个邮件地址之后点击 “Test configuration” 发送测试邮件

2.2.4.3

2.2.4.4

完成上述邮件配置之后，我们还需要进入已经构建的 test 任务里去配置接收邮件的地址

在 “增加构建后操作步骤” 中，选择 “E-mail Notification”，然后在 “Recipients” 中填写邮箱的地址

2.2.4.5

输入完成之后保存

2.2.5 插件 email-ext

进入 “Dashboard” → “Manage Jenkins” → “Plugins” 里面查看 “Installed plugins”(已安装插件) 里面有没有 “Email Extension Plugin”，没有的话就到 “Available plugins”(可用插件) 里面去安装

2.2.5.1

然后回到 “Dashboard” → “Manage Jenkins” → “System”

由于我们要使用 Extended E-mail Notification(email-ext) 去代替 “E-mail Notification”，所以我们需要先把 “E-mail Notification” 里设置的内容删掉

2.2.5.2

删除 “E-mail Notification” 内容之后，配置 “Extended E-mail Notification”

“SMTP Server” 中填入 smtp.qq.com
“SMTP Port” 中填入 465
然后在 “Credentials” 里面 Add 一下
- Username 填入发件人的邮箱地址
- Password 填入刚才获得的 SMTP 的登陆密码
然后创建完成之后，选择一下刚刚创建的
然后下滑找到 “Default Triggers” 在里面选择上 “Always”

然后我们回到刚才创建的 test 任务，下拉找到 “Post-build Actions”(构建后操作) 然后点击 “Add post-build action”(增加构建后操作)，然后点击 “Editable Email Notification”，其中 “Project Recipient List” 为收件人，可在默认内容后面增加额外的收件人邮箱，使用 , 进行分割

2.2.5.6

然后往下翻，点击 “Advanced Settings”(高级设置) 然后找到 “Triggers”(触发器)，然后点击 “Add Trigger”(添加触发器) 然后点击 “Always”

2.2.5.7

保存配置后，我们回到 “test” 任务下，点击 “Build Now” 构建一个

可以看到，邮件发送成功

2.2.5.8

2.2.5.9

三、Jenkins 使用

3.1 Jenkins 破解管理员密码

1
2
3
4
5
6


$ ll /var/lib/jenkins/users/
总计 16
drwxr-xr-x  3 jenkins jenkins 4096 12月 16 08:45 ./
drwxr-xr-x 15 jenkins jenkins 4096 12月 16 16:48 ../
drwx------  2 jenkins jenkins 4096 12月 16 12:19 admin_1349963450593177270/
-rw-r--r--  1 jenkins jenkins  300 12月 16 08:45 users.xml

这里能看到我们用户的文件夹是 /var/lib/jenkins/users/admin_1349963450593177270/ 编辑里面的 config.xml 文件

1
2
3
4
5
6


$ vim /var/lib/jenkins/users/admin_1349963450593177270/config.xml
# 找到里面 'passwordHash' 的那行，修改为
<passwordHash>#jbcrypt:$2a$10$usctvlMlqJ8XswbJ0QCcRuZ6ItKL30r0mEXXi5cXCrnWITuyP2E5W</passwordHash>

# 重启 Jenkins
$ sudo systemctl restart jenkins

新密码为 000000

不想使用上述的密码，我们也可以自己定义一个随机字符串，进入 Jenkins 界面，点击右上角 admin，点击设置，下拉找到 “密码”，自己定义一个随机字符串，将自己定义的随机字符串保存下来，位置自由，若以后忘记了密码，可在 /var/lib/jenkins/users/admin 文件中，将字符串修改成自己定义的字符串，这样密码就修改成功了

3.2 Jenkins 部署 java 项目

Step 1 连接代码仓库并测试

首先，全局配置 Git 用户信息

1
2
3


$ cd /home/
$ git config --global user.name "AnitsuriW"
$ git config --global user.email "moka@anitsuri.top"

所有的 Git 提交都会使用这两项信息，便于识别贡献者

然后，创建一个项目目录，用于存放本地存储库，然后初始化本地存储库

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


$ sudo mkdir test
$ cd test

# 初始化本地存储库
$ git init
提示：使用 'master' 作为初始分支的名称。这个默认分支名称可能会更改。要在新仓库中
提示：配置使用初始分支名，并消除这条警告，请执行：
提示：
提示：  git config --global init.defaultBranch <名称>
提示：
提示：除了 'master' 之外，通常选定的名字有 'main'、'trunk' 和 'development'。
提示：可以通过以下命令重命名刚创建的分支：
提示：
提示：  git branch -m <name>
已初始化空的 Git 仓库于 /home/test/.git/

新建一个 README.md 文件，并填写上内容，并提交

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27


$ touch README.md
$ echo "This is test2 repo" >> README.md

# 添加文件到 Git 暂存区
# 只有在 Git 暂存区的内容，才能被 commit
$ git add README.md

# 向本地的库提交先前的更改
$ git commit -m "first commit"
[master （根提交） 6c7cf6a] first commit
 1 file changed, 1 insertion(+)
 create mode 100644 README.md
 
# 添加远程仓库地址
$ git remote add origin https://github.com/AnitsuriW/test2.git

# 将代码推送到远程仓库
$ git push -u origin master
Username for 'https://github.com': AnitsuriW
Password for 'https://AnitsuriW@github.com': 
枚举对象中: 3, 完成.
对象计数中: 100% (3/3), 完成.
写入对象中: 100% (3/3), 225 字节 | 225.00 KiB/s, 完成.
总共 3（差异 0），复用 0（差异 0），包复用 0
To https://github.com/AnitsuriW/test2.git
 * [new branch]      master -> master
分支 'master' 设置为跟踪 'origin/master'。

Username for 'https://github.com' 里面填入你 Github 的用户名
Password for 'https://AnitsuriW@github.com' 里面是需要填入你的个人访问令牌(Personal Access Token)，才可以访问：
- 登录 GitHub 账号，访问个人访问令牌页面
- 点击 Generate new token，选择合适的权限（通常需要选择 repo 权限）

以上操作执行完成后，再次访问代码仓库，就可以看到刚推送成功的 README.md 文件

3.2.1

然后我们修改 README.md 文件里面的内容，再次做推送到代码仓库

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


$ echo "change twice to test it works" >> README.md
$ echo "change twice to test it works" >> README.md
$ git add README.md
$ git commit -m "second commit"
[master 63eca76] second commit
 1 file changed, 2 insertions(+)
$ git push -u origin master
Username for 'https://github.com': AnitsuriW
Password for 'https://AnitsuriW@github.com': 
枚举对象中: 5, 完成.
对象计数中: 100% (5/5), 完成.
使用 4 个线程进行压缩
压缩对象中: 100% (2/2), 完成.
写入对象中: 100% (3/3), 282 字节 | 282.00 KiB/s, 完成.
总共 3（差异 0），复用 0（差异 0），包复用 0
To https://github.com/AnitsuriW/test2.git
   6c7cf6a..63eca76  master -> master
分支 'master' 设置为跟踪 'origin/master'。

以上操作执行完成后，再次访问代码仓库，就可以看到 README.md 文件的内容发生更改，推送成功

3.2.2

Step 2 下载 Zrlog

为了让我们的实验更加接近现实中的生产环境，我们需要一段 Java 的源代码，所以此处我们下载由 Java 编写的博客 — zrlog

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


$ cd /home
$ wget https://codeload.github.com/94fzb/zrlog/zip/master
--2024-12-17 06:35:31--  https://codeload.github.com/94fzb/zrlog/zip/master
正在解析主机 codeload.github.com (codeload.github.com)... 20.205.243.165
正在连接 codeload.github.com (codeload.github.com)|20.205.243.165|:443... 已连接。
已发出 HTTP 请求，正在等待回应... 200 OK
长度： 未指定 [application/zip]
正在保存至: ‘master’

master                          [    <=>                                   ]   3.20M  4.32MB/s    用时 0.7s  

2024-12-17 06:35:32 (4.32 MB/s) - ‘master’ 已保存 [3351642]

# 查看 master 包的大小
$ du -sh master
3.2M    master

# 解压 master
$ unzip master

# 将 zrlog 的内容移动到 test 中
$ mv zrlog-master/* test/

Step 3 提交代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


$ cd test/

# 将当前所有更改都添加到下一个提交
$ git add .

# 提交上面进行的更改
$ git commit -m "add zrlog"

# 推送到远程仓库上
$ git push
Username for 'https://github.com': AnitsuriW
Password for 'https://AnitsuriW@github.com': 
枚举对象中: 802, 完成.
对象计数中: 100% (802/802), 完成.
使用 4 个线程进行压缩
压缩对象中: 100% (714/714), 完成.
写入对象中: 100% (800/800), 2.37 MiB | 1.91 MiB/s, 完成.
总共 800（差异 111），复用 0（差异 0），包复用 0
remote: Resolving deltas: 100% (111/111), done.
To https://github.com/AnitsuriW/test2.git
   63eca76..f3af493  master -> master

然后进入到代码仓库查看，可以看到我们刚才提交的文件，说明提交成功

3.2.3

3.3 安装 JDK（在 java 上）

在 Oracle 官网下载 jdk-8u431-linux-x64.tar.gz 到 /usr/local 目录下

1
2
3
4
5
6
7
8
9


$ cd /usr/local

# 新建一个 java 目录，将文件移到该目录下
$ sudo mkdir java
$ mv jdk-8u431-linux-x64.tar.gz /usr/local/java/jdk-8u431-linux-x64.tar.gz

# 然后解压
$ cd java
$ tar -zxf jdk-8u431-linux-x64.tar.gz

然后配置 Java 的环境变量

1
2
3
4
5
6
7
8
9


# 编辑环境变量文件
$ sudo vim /etc/profile
# 添加如下内容
export JAVA_HOME=/usr/local/java/jdk1.8.0_431
export PATH=$JAVA_HOME/bin:$PATH
export CLASSPATH=.:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar

# 然后刷新环境变量
$ source /etc/profile

最后验证一下

1
2
3
4


$ java -version
java version "1.8.0_431"
Java(TM) SE Runtime Environment (build 1.8.0_431-b10)
Java HotSpot(TM) 64-Bit Server VM (build 25.431-b10, mixed mode)

3.4 安装 tomcat（在 java 上）

tomcat 是用来运行 zrlog 的容器

在 /usr/local 目录下，执行以下命令

1
2
3
4
5
6
7
8


# 下载
$ cd /usr/local
$ curl -O https://dlcdn.apache.org/tomcat/tomcat-9/v9.0.98/bin/apache-tomcat-9.0.98.tar.gz

# 解压
$ tar -zxf apache-tomcat-9.0.98.tar.gz
$ mv /usr/local/apache-tomcat-9.0.98 /usr/local/tomcat
$ vim /usr/local/tomcat/conf/tomcat-users.xml

替换 /usr/local/tomcat/conf/tomcat-users.xml 为以下内容，用来配置管理员用户

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65


<?xml version="1.0" encoding="UTF-8"?>
<!--
  Licensed to the Apache Software Foundation (ASF) under one or more
  contributor license agreements.  See the NOTICE file distributed with
  this work for additional information regarding copyright ownership.
  The ASF licenses this file to You under the Apache License, Version 2.0
  (the "License"); you may not use this file except in compliance with
  the License.  You may obtain a copy of the License at

      http://www.apache.org/licenses/LICENSE-2.0

  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.
-->
<tomcat-users xmlns="http://tomcat.apache.org/xml"
              xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
              xsi:schemaLocation="http://tomcat.apache.org/xml tomcat-users.xsd"
              version="1.0">
<!--
  By default, no user is included in the "manager-gui" role required
  to operate the "/manager/html" web application.  If you wish to use this app,
  you must define such a user - the username and password are arbitrary.

  Built-in Tomcat manager roles:
    - manager-gui    - allows access to the HTML GUI and the status pages
    - manager-script - allows access to the HTTP API and the status pages
    - manager-jmx    - allows access to the JMX proxy and the status pages
    - manager-status - allows access to the status pages only

  The users below are wrapped in a comment and are therefore ignored. If you
  wish to configure one or more of these users for use with the manager web
  application, do not forget to remove the <!.. ..> that surrounds them. You
  will also need to set the passwords to something appropriate.
-->
<!--
  <user username="admin" password="<must-be-changed>" roles="manager-gui"/>
  <user username="robot" password="<must-be-changed>" roles="manager-script"/>
-->
<!--
  The sample user and role entries below are intended for use with the
  examples web application. They are wrapped in a comment and thus are ignored
  when reading this file. If you wish to configure these users for use with the
  examples web application, do not forget to remove the <!.. ..> that surrounds
  them. You will also need to set the passwords to something appropriate.
-->

  <role rolename="admin"/>
  <role rolename="admin-gui"/>
  <role rolename="admin-script"/>
  <role rolename="manager"/>
  <role rolename="manager-gui"/>
  <role rolename="manager-script"/>
  <role rolename="manager-jmx"/>
  <role rolename="manager-status"/>
  <user username="admin" password="jenkins.com" roles="admin,manager,admin-gui,admin-script,manager-gui,manager-script,manager-jmx,manager-status" />

<!--
  <user username="tomcat" password="<must-be-changed>" roles="tomcat"/>
  <user username="both" password="<must-be-changed>" roles="tomcat,role1"/>
  <user username="role1" password="<must-be-changed>" roles="role1"/>
-->
</tomcat-users>

用户名：admin
密码：jenkins.com

然后我们编辑 /usr/local/tomcat/webapps/manager/META-INF/context.xml 文件

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


$ vim /usr/local/tomcat/webapps/manager/META-INF/context.xml
# 找到 allow 那行，变成以下内容
allow="127\.\d+\.\d+\.\d+|::1|0:0:0:0:0:0:0:1|192.168.100.*" />

# 配置成功之后启动 tomcat
$ /usr/local/tomcat/bin/startup.sh
Using CATALINA_BASE:   /usr/local/tomcat
Using CATALINA_HOME:   /usr/local/tomcat
Using CATALINA_TMPDIR: /usr/local/tomcat/temp
Using JRE_HOME:        /usr/local/java/jdk1.8.0_431
Using CLASSPATH:       /usr/local/tomcat/bin/bootstrap.jar:/usr/local/tomcat/bin/tomcat-juli.jar
Using CATALINA_OPTS:   
Tomcat started.

验证

登录网址 http://192.168.100.131:8080

3.4.1

然后找到 “Managing Tomcat” 点击 “manager webapp”

3.4.2

然后输入 tomcat 的用户名和密码

3.4.3

完成验证后，成功进入 manager 平台，说明 tomcat 各项配置均配置成功

3.4.4

3.5 安装 maven（在 Jenkins 上）

在 /usr/local 目录下，执行以下操作

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


# 下载
$ cd /usr/local
$ curl -O https://dlcdn.apache.org/maven/maven-3/3.8.8/binaries/apache-maven-3.8.8-bin.tar.gz

# 解压
$ tar -zxf apache-maven-3.8.8-bin.tar.gz

# 验证
$ /usr/local/apache-maven-3.8.8/bin/mvn --version
Apache Maven 3.8.8 (4c87b05d9aedce574290d1acc98575ed5eb6cd39)
Maven home: /usr/local/apache-maven-3.8.8
Java version: 17.0.13, vendor: Ubuntu, runtime: /usr/lib/jvm/java-17-openjdk-amd64
Default locale: zh_CN, platform encoding: UTF-8
OS name: "linux", version: "6.8.0-50-generic", arch: "amd64", family: "unix"

然后在 Jenkins 里，依次点击 “Manage Jenkins” → “Tools” 填入 Maven 相关的文件路径

3.5.2.1

往下翻找到 Maven，点击“新增Maven”，按照安装的 Maven 版本号来填写 Name，此处建议不要开启自动安装，所以不要勾选“自动安装”，然后在 Jenkins 服务器上获取的 Maven 路径填入 MAVEN_HOME ，应用保存即可

3.5.2.2

3.6 安装插件

我们这里安装 Maven Integration 和 Deploy to container 这两个插件

3.6.1.2 3.6.1.2

然后重启 Jenkins

1

$ sudo systemctl restart jenkins

然后回到 Dashboard 页面，点击 “新建Item”，当出现 “构建一个 maven 项目” 说明安装成功

3.6.3

3.7 创建 maven 项目

接着上面的来，在 “输入一个任务名称” 里面填写一个任务名称，并选择想要构建的项目类型，这里我们选择 “构建一个 maven 项目”

3.7.1

配置 “源码管理”，选择 “git” 来进行源码管理，将私有的代码仓库地址填入 “Repository URL”，此时会出现错误提示

3.7.2

这是因为我们添加的代码仓库是私有的，想要使用它就必须为它添加凭证

在 “Credentials”(凭证) 里面点击 “添加”

3.7.3

“类型” 选择 “SSH Username with private key”、

“Username” 为 “git”（以代码仓库的地址为参考，可知此处使用的用户名应为git）

勾选 “Enter directly”，并将服务器的私钥（~/.ssh/id_rsa）添加到出现的 “key” 中，从而使得 Jenkins 可以成功访问到 Git

3.7.4

然后到 Github 的密钥设置(Setting→Key) 里面的 SSH Keys 新建一个 New SSH Key，Title 任意起，Key Type 就默认 Authentication Key 就好，Key 里面的内容填入 ~/.ssh/id_rsa.pub 的公钥，然后保存

然后切换到 Jenkins 用户，并为其添加上我们 root 用户的公钥

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


$ sudo -u jenkins -i

# 新建 SSH 目录
$ mkdir -p ~/.ssh
$ chmod 700 ~/.ssh

# 复制 GitHub 的主机密钥到 known_hosts 文件
$ ssh-keyscan github.com >> ~/.ssh/known_hosts
$ chmod 644 ~/.ssh/known_hosts

# 然后退出，使用 root 用户
$ exit

# 复制公钥和私钥到 jenkins 用户并给予权限
$ cp /root/.ssh/id_rsa /var/lib/jenkins/.ssh/
$ cp /root/.ssh/id_rsa.pub /var/lib/jenkins/.ssh/
$ chown jenkins:jenkins /var/lib/jenkins/.ssh/id_rsa /var/lib/jenkins/.ssh/id_rsa.pub
$ chmod 600 /var/lib/jenkins/.ssh/id_rsa
$ chmod 644 /var/lib/jenkins/.ssh/id_rsa.pub

# 然后切换回 jenkins 用户并测试
$ sudo -u jenkins -i
$ ssh -T git@github.com
Hi AnitsuriW! You've successfully authenticated, but GitHub does not provide shell access.

“Credentials” 添加完成之后，在 “Credentials” 下选择 “git”，此时可以看到刚才出现的错误提示已经消失了

3.7.5

往下翻，找到 “Build”（其功能实质上就是用 maven 去编译我们的源码生成包）

然后里面的 “Root POM” 就默认 “pom.xml” 即可

“Goals and options” 下面填写 maven 在编译时用到的选项，正常可留空，但是我们这里填写 clean install -D maven.test.skip=true，这条命令表示在编译之前先清理，跳过测试

3.7.6

下滑点击 “增加构建后操作步骤” 选择 “Editable Email Notification”，在 “Project Recipient List” 下添加一个额外的邮箱,注意前后需要使用英文逗号隔开，应用，保存

3.7.7

点击 “Build Now” 之后，可以看到左下角出现了错误，点击此进程，查看 “控制台输出”

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


'[ERROR] Failed to execute goal org.apache.maven.plugins:maven-compiler-plugin:3.11.0:compile (default-compile) on project common: Fatal error compiling: 错误: 无效的目标发行版：21 -> [Help 1]'
[ERROR] 
[ERROR] To see the full stack trace of the errors, re-run Maven with the -e switch.
[ERROR] Re-run Maven using the -X switch to enable full debug logging.
[ERROR] 
[ERROR] For more information about the errors and possible solutions, please read the following articles:
[ERROR] [Help 1] http://cwiki.apache.org/confluence/display/MAVEN/MojoExecutionException
[ERROR] 
[ERROR] After correcting the problems, you can resume the build with the command
[ERROR]   mvn <goals> -rf :common
[JENKINS] Archiving /var/lib/jenkins/workspace/test_java/admin-web/pom.xml to com.zrlog/admin-web/3.1.4-SNAPSHOT/admin-web-3.1.4-SNAPSHOT.pom
[JENKINS] Archiving /var/lib/jenkins/workspace/test_java/data/pom.xml to com.zrlog/data/3.1.4-SNAPSHOT/data-3.1.4-SNAPSHOT.pom
[JENKINS] Archiving /var/lib/jenkins/workspace/test_java/admin-token/pom.xml to com.zrlog/admin-token/3.1.4-SNAPSHOT/admin-token-3.1.4-SNAPSHOT.pom
[JENKINS] Archiving /var/lib/jenkins/workspace/test_java/blog-web/pom.xml to com.zrlog/blog-web/3.1.4-SNAPSHOT/blog-web-3.1.4-SNAPSHOT.pom
[JENKINS] Archiving /var/lib/jenkins/workspace/test_java/common/pom.xml to com.zrlog/common/3.1.4-SNAPSHOT/common-3.1.4-SNAPSHOT.pom
[JENKINS] Archiving /var/lib/jenkins/workspace/test_java/pom.xml to com.zrlog/zrlog/3.1.4-SNAPSHOT/zrlog-3.1.4-SNAPSHOT.pom
[JENKINS] Archiving /var/lib/jenkins/workspace/test_java/service/pom.xml to com.zrlog/service/3.1.4-SNAPSHOT/service-3.1.4-SNAPSHOT.pom
[JENKINS] Archiving /var/lib/jenkins/workspace/test_java/package-web/pom.xml to com.zrlog/package-web/3.1.4-SNAPSHOT/package-web-3.1.4-SNAPSHOT.pom
[JENKINS] Archiving /var/lib/jenkins/workspace/test_java/web/pom.xml to com.zrlog/web/3.1.4-SNAPSHOT/web-3.1.4-SNAPSHOT.pom
channel stopped
Finished: FAILURE

其主要的错误是 “错误: 无效的目标发行版：21” 他要求 Java JDK 21 版本

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


# 安装 JDK 21
$ sudo yum install -y openjdk-21-jdk
# 配置 JDK 21 为主要使用
$ update-alternatives --config java
有 2 个候选项可用于替换 java (提供 /usr/bin/java)。

  选择       路径                                       优先级  状态
------------------------------------------------------------
* 0            /usr/lib/jvm/java-21-openjdk-amd64/bin/java   2111      自动模式
  1            /usr/lib/jvm/java-17-openjdk-amd64/bin/java   1711      手动模式
  2            /usr/lib/jvm/java-21-openjdk-amd64/bin/java   2111      手动模式

# 检验
$ java -version
openjdk version "21.0.5" 2024-10-15
OpenJDK Runtime Environment (build 21.0.5+11-Ubuntu-1ubuntu124.04)
OpenJDK 64-Bit Server VM (build 21.0.5+11-Ubuntu-1ubuntu124.04, mixed mode, sharing)

然后我们重新 Build 一下，然后可以看到 Success 说明编译成功

3.7.8

3.8 发布 war 包

到我们刚刚创建的任务 “test_java” 的配置里面，找到 “构建后操作”，然后点击 “Deploy war/ear to a container”

然后里面的

WAR/EAR files 填写 **/*.war
Context path 留空
Containers 我们这里选择 Tomcat 9.x Remote
- 这里需要根据实际的 Tomcat 进行修改，而我们上面安装的是 Tomcat 9.0.88，所以我们这里选择 Tomcat 9.x Remote
- 在这里面的 “Credentials” 下面点击添加，然后选择 “Jenkins”，然后填入上面说的 tomcat 的账号和密码
  
  然后添加后选择
- Tomcat URL 这里填写 http://192.168.100.131:8080

3.8.2

保存后，点击 “Build Now” 构建成功后，在 java 服务器上查看远程目录 /usr/local/tomcat/webapps 中是否存在刚刚构建成功发布的 war 包

3.8.3

CI/CD 基础学习

以 Jenkins 集成部署为例，了解了 CI/CD 流程，上手了解了 Jenkins 的使用，以及 git 在实际开发中的简单用法