自动化运维之Jenkins 与 Git 实战（二）（Jenkins and Git Practice in Automated Operations and Maintenance Part 2）

 💝💝💝欢迎来到我的博客，很高兴能够在这里和您见面！希望您在这里可以感受到一份轻松愉快的氛围，不仅可以获得有趣的内容和知识，也可以畅所欲言、分享您的想法和见解。

本人主要分享计算机核心技术:系统维护、数据库、网络安全、自动化运维、容器技术、云计算、人工智能、运维开发、算法结构、物联网、JAVA 、Python、PHP、C、C++等。
不同类型针对性训练,提升逻辑思维,剑指大厂，非常期待和您一起在这个小小的网络世界里共同探索、学习和成长。

自动化运维之Jenkins 与 Git 实战（二）

4.1 案例分析

4.1.1 案例概述

在前面的 Jenkins 课程中，更多强调的是 Jenkins 使用和项目部署，而本章将结合新项

目来实现自动化构建及发布，并将项目打包成镜像上传到私有仓库，来实现一键发布、回滚

等操作。

4.1.2 案例前置知识点

1. Jenkins 介绍

原名 Hudson，2011 年改为现在的名字，它是一个开源的实现持续集成与发布

的软件工具。官方网站：https://jenkins.io/。是一个开源的自动化服务器，广泛用于持续集成和持续交付（CI/CD）领域。它允许开发团队自动化各种任务，包括构建、测试和部署应用程序。Git则是一个分布式版本控制系统，用于管理软件开发过程中的代码变更。将Jenkins与Git结合使用，可以实现代码的自动化构建、测试和部署，从而提高软件开发和运维的效率。

在自动化运维的实践中，Jenkins与Git的结合可以带来诸多好处。例如，通过Jenkins的自动化脚本，可以定期从Git仓库中拉取最新的代码进行构建，执行自动化测试，并在测试通过后自动部署到生产环境。这种做法不仅减少了手动操作的错误，还加快了软件的发布周期。此外，Jenkins的插件机制使得它可以轻松集成各种工具和服务，包括代码质量检查工具、性能测试工具等，进一步增强了其功能。

在实际操作中，开发人员可以通过安装特定的Jenkins插件来增强与Git的集成能力。例如，安装Git参数插件可以使Jenkins在构建过程中接受Git标签作为输入，从而实现更加灵活的构建和部署策略。此外，通过Jenkins的流水线配置，可以定义一系列有序的操作，包括代码检查、构建、测试和部署，确保每个阶段都按照预定的标准进行，从而提高了软件的质量和可靠性。

2. Maven 介绍

Maven 是一个软件项目管理及自动构建工具，由 Apache 软件基金会所提供。基于项

目对象模型（缩写：POM）概念，Maven 利用一个中央信息片断来管理一个项目的构建、

报告和文档等步骤。

3. Docker 介绍

Docker 是一个开源的容器应用引擎，让开发者可以打包他们的应用及依赖包到任意一

个可移植的镜像中，然后发布到任何一个流行的 Linux 机器上。

4. Ansible 介绍

Ansible 是一种自动化运维工具，基于 Python 开发，实现了批量系统配置、批量程序

部署、批量运行命令等功能。

4.1.3 案例环境

1. 本案例环境

本章案例共使用三台服务器，每台服务器担任不同的服务角色，最后通过配置 Jenkins

实现自动打包部署 Java 项目。案例实验环境如表 4-1 所示。

表 4-1 Git+Jenkins 基本环境

主机	操作系统	主机名/IP 地址	主要软件及版本
服务器	CentOS 7.3-x86_64	jenkins/192.168.8.217	Jenkins/Docker
服务器	CentOS 7.3-x86_64	docker/192.168.8.218	Docker
服务器	CentOS 7.3-x86_64	repository/192.168.8.219	Git/Docker registry

2. 案例拓扑

实验拓扑如图 4.1 所示。 图 4.1 实验拓扑

如图 4.1 所示，开发者将开发完成的代码提交到 Git 代码仓库，Jenkins 自动拉取编译

构建，并自动部署到 Web 服务器。

3. 案例需求

开发者将代码提交到 Git 代码仓库后，实现 Jenkins 自动拉取代码编译构建，并自动部

署到 Web 服务器，用户可以访问最新版本的项目程序。

4. 实现思路

（1）通过 Git 版本控制系统存放项目代码。

（2）使用 Jenkins 自动化部署项目。

（3）基于 Docker 引擎创建项目容器。

（4）使用 Ansible 集中管理 Web 服务器。

4.2 案例实施

4.2.1 准备 Git 仓库

Git 是一个开源的分布式版本控制系统，可以有效、高速的处理从很小到非常大的项目

版本管理问题，是目前企业中使用最为广泛的代码版本管理系统。

1. 使用 YUM 安装并配置 Git

三台主机都需要修改主机名、关闭防火墙和禁用 SELinux。在 repository 主机上，安装

Git，并配置 Git 用户。

（1）安装 Git

[root@repository ~]# yum install git -y

（2）创建 Git 用户并设置密码

[root@repository ~]# useradd git

[root@repository ~]# passwd git

//输入两次要设置的密码

2. 配置 Jenkins 主机免交互拉取 Git 仓库

在 Jenkins 主机上创建密钥对，将 id_rsa.pub 内容追加到 Git 服务器上的

/home/git/.ssh/authorized_keys 文件中。

[root@jenkins ~]# ssh-keygen

//一路回车即可

[root@jenkins ~]# ssh-copy-id git@192.168.8.219测试免交互登录。

[root@jenkins ~]# ssh git@192.168.8.219

4.2.2 准备 Jenkins 环境

Jenkins 是一个开源软件项目，是基于 Java 开发的一种持续集成工具，用于代码编译、

部署、测试等工作。 Jenkins 也是一个跨平台的集成工具，大多数主流平台都支持，而且

安装简单。这里，将以 war 包方式安装部署。

（1）Java 环境安装

在安装 Jenkins 之前，需要具备 Java 环境。Java 环境的安装方式如下所示。

[root@jenkins ~]# tar zxf jdk-8u202-linux-x64.tar.gz

[root@jenkins ~]# mv jdk1.8.0_202 /usr/local/java

[root@jenkins ~]# vim /etc/profile

export JAVA_HOME=/usr/local/java

export CLASSPATH=$JAVA_HOME/lib/tools.jar:$JAVA_HOME/lib/dt.jar

export PATH=$JAVA_HOME/bin:$PATH

[root@jenkins ~]# source /etc/profile

[root@jenkins ~]# java -version

java version "1.8.0_202"

Java(TM) SE Runtime Environment (build 1.8.0_202-b08)

Java HotSpot(TM) 64-Bit Server VM (build 25.202-b08, mixed mode)

（2）在 Tomcat 环境下，部署 Jenkins

[root@jenkins ~]# tar zxf apache-tomcat-8.5.56.tar.gz

[root@jenkins ~]# mv apache-tomcat-8.5.56 /usr/local/tomcat

//先将 jenkins.war 软件包上传到/usr/local/tomcat/webapps 目录中

[root@jenkins ~]# cd /usr/local/tomcat/bin/

[root@jenkins ~]# ./startup.sh

在浏览器中输入 http://192.168.8.217:8080/jenkins/ 进入 Jenkins 部署页面，如图 4.2

所示。

图 4.2 解锁 jenkins

在 Jenkins 主机上，查看/root/.jenkins/secrets/initialAdminPassword 文件，获取管理

员密码，将获取的密码输入“管理员密码”输入框内。然后，单击“继续”按钮，进入自定义

Jenkins 插件安装界面，如图 4.3 所示。

图 4.3 自定义 Jenkins 插件安装

单击“安装推荐的插件”按钮，进入插件安装界面。等待插件安装完成后，进入管理员账

户配置界面，并进行如图 4.4 所示配置。

图 4.4 管理员设置

完成管理员用户配置后，点击“保存并完成”按钮。最后，单击“开始使用 Jenkins”，进入

Jenkins 首页，如图 4.5 所示。

图 4.5 Jenkins 首页

4.2.3 基于 Jenkins+Git+Docker 发布 Java 项目

1. 安装 Docker 服务

在三台主机上，分别执行以下操作。

[root@docker ~]# yum install -y yum-utils device-mapper-persistent-data lvm2 //安装依赖包

[root@docker

~]#

yum-config-manager

--add-repo

https://download.docker.com/linux/centos/docker-ce.repo

//添加 Docker 软件包源

[root@docker ~]# yum install docker-ce -y

// 安装 Docker CE

[root@docker ~]# mkdir /etc/docker

[root@docker ~]# vim /etc/docker/daemon.json

//配置 Docker 镜像加速

{

"registry-mirrors": [

"http://registry.docker-cn.com"

]

}

[root@docker ~]# systemctl start docker && systemctl enable docker

2. 部署镜像仓库

Docker Hub 是 Docker 默认的官方公共镜像仓库。如果用户想自己搭建私有镜像仓库，

官方提供了 registry 镜像，通过该镜像搭建私有仓库将变得非常简单。

（1）部署私有仓库

[root@repository ~]# docker run -d -v /opt/registry:/var/lib/registry -p 5000:5000

--restart=always --name registry registry

[root@repository ~]# docker ps -l

CONTAINER ID

IMAGE

COMMAND

CREATED

STATUS

PORTS

NAMES

88484f2b104d

registry

"/entrypoint.sh /etc…"

35 seconds ago

Up 32

seconds

0.0.0.0:5000->5000/tcp

registry

（2）测试私有仓库可用性

由于 Docker CLI 默认以 HTTPS 访问，而部署的 registry 并未提供 HTTPS。因此，需

要在 pull 镜像的 Docker 主机（192.168.8.217，192.168.8.218）添加 HTTP 可信任。具体

配置如下所示。

[root@jenkins ~]# vim /etc/docker/daemon.json

{

"registry-mirrors": ["http://registry.docker-cn.com"],

"insecure-registries": ["192.168.8.219:5000"]

}

[root@jenkins ~]# systemctl restart docker

[root@docker ~]# vim /etc/docker/daemon.json

{

"registry-mirrors": ["http://registry.docker-cn.com"],

"insecure-registries": ["192.168.8.219:5000"]

}

[root@docker ~]# systemctl restart docker打标签，并推送镜像到 registry。

[root@docker ~]# docker pull centos:7

[root@docker ~]# docker tag centos:7 192.168.8.219:5000/centos:7

[root@docker ~]# docker push 192.168.8.219:5000/centos:7

查看 registry 上传的镜像。

[root@docker ~]# curl http://192.168.8.219:5000/v2/_catalog

{"repositories":["centos"]}

[root@docker ~]# curl http://192.168.8.219:5000/v2/centos/tags/list

{"name":"centos","tags":["7"]}

从 registry 下载镜像。

[root@docker ~]# docker rmi 192.168.8.219:5000/centos:7

[root@docker ~]# docker pull 192.168.8.219:5000/centos:7

3. 构建 Tomcat 基础镜像

Java 程序必须有 JDK 环境才可以运行。为了减少镜像大小及提高性能，直接把 JDK

放到宿主机上，在容器中以挂载形式使用。

在 Docker 主机上，安装 JDK。

[root@docker ~]# tar zxvf jdk-8u202-linux-x64.tar.gz

[root@docker ~]# mv jdk1.8.0_202 /usr/local/java

编写 Tomcat 基础镜像 Dockerfile 文件，Tomcat 安装文件和 Dockerfile 文件放到同一

目录下。

[root@docker ~]# vim Dockerfile

FROM centos:7

MAINTAINER www.kgc.cn

ENV VERSION=8.5.56

ENV JAVA_HOME /usr/local/java

RUN yum install wget curl unzip iproute net-tools -y && \

yum clean all && \

rm -rf /var/cache/yum/*

ADD apache-tomcat-${VERSION}.tar.gz /usr/local/

RUN mv /usr/local/apache-tomcat-${VERSION} /usr/local/tomcat && \

rm -rf /usr/local/tomcat/webapps/* && \

mkdir /usr/local/tomcat/webapps/ROOT && \

echo "ok" > /usr/local/tomcat/webapps/ROOT/status.html && \

sed -i '1a JAVA_OPTS="-Djava.security.egd=file:/dev/./urandom"'

/usr/local/tomcat/bin/catalina.sh && \

ln -sf /usr/share/zoneinfo/Asia/Shanghai /etc/localtime

ENV PATH $PATH:/usr/local/tomcat/bin

WORKDIR /usr/local/tomcat

EXPOSE 8080

CMD ["catalina.sh", "run"]

构建镜像，并上传到 registry。

[root@docker ~]# docker build -t tomcat-85 -f Dockerfile .

[root@docker ~]# docker tag tomcat-85 192.168.8.219:5000/tomcat-85

[root@docker ~]# docker push 192.168.8.219:5000/tomcat-85

4. Jenkins 全局工具配置

Jenkins 主机安装 Git 命令及 maven 环境，安装命令如下。

[root@jenkins ~]# tar zxf apache-maven-3.6.0-bin.tar.gz

[root@jenkins ~]# mv apache-maven-3.6.0 /usr/local/maven

[root@jenkins ~]# yum install git -y

在 Jenkins 首页中，选择“系统管理”→“全局工具配置”，如图 4.6 所示。

图 4.6 全局工具配置项

指定 JDK 路径，Git 保持默认，如图 4.7 所示。

图 4.7 Java 配置

指定 Maven 路径，如图 4.8 所示。

图 4.8 Maven 配置

设置完成后，单击“保存”按钮完成设置。

5. Jenkins 安装必要插件

在 Jenkins 首页中选择“系统管理”→“插件管理”，如图 4.9 所示。

图 4.9 插件管理选项

进入“可选插件”安装页面，如图 4.10 所示。

图 4.10 可选插件安装界面

在搜索框内，输入 SSH 关键字进行搜索。将 SSH 插件前方的复选框选中，单击“直接

安装”，如图 4.11 所示。

图 4.11 SSH 插件安装

使用上述同样方法，安装 Git Parameter 插件和 Maven Integration 插件，如图 4.12 和

4.13 所示。

图 4.12 Git Parameter 插件安装

图 4.13 Maven Integration 插件安装

插件说明：

 SSH：用于 SSH 远程 Docker 主机执行 Shell 命令。

 Git Parameter：用于动态获取 Git 仓库 Branch、Tag。

 Maven Integration：用于支持构建 Maven 项目。

6. 配置 SSH 插件

（1）创建凭据

创建一个用于连接 Docker 主机的凭据。在 Jenkins 首页中，选择右上角“admin 用

户”→“凭据”→最下侧的“Jenkins”→“全局凭据”→“添加凭据”，如图 4.14 所示。

图 4.14 添加凭据

输入连接 Docker 主机的用户名和密码，单击“保存”按钮，如图 4.15 所示。

图 4.15 填写凭据内容

（2）添加 SSH 远程主机

在 Jenkins 首页中，选择“系统管理”→“系统配置”，如图 4.16 所示。

图 4.16 系统设置选项

（3）配置 SSH remote hosts

在 SSH remote hosts 配置模块中，单击“新增”后，填写配置内容，并单击“Check

connection”按钮进行连接测试。如果成功连接，会有“Successfull conncection”的提示字符，

如图 4.17 所示。最后，单击“保存”按钮完成 SSH 插件配置。

图 4.17 SSH remote hosts 设置

7. 上传 Java 项目代码到 Git 仓库

在 Git 服务器创建 solo 版本仓库，Git 仓库的命名规范一般以.git 为后缀。

[root@repository ~]# su - git

[root@repository ~]# mkdir solo.git

[root@repository ~]# cd solo.git

[root@repository ~]# git --bare init

//初始化空的 Git 版本库于 /home/git/solo.git/

上传开源 Java 博客系统 solo 压缩包，并解压。

[root@jenkins ~]# tar zxf solo-2.9.1.tar.gz

//压缩包随案例文档发布

克隆 Git 服务器上的 solo 仓库。

[root@jenkins ~]# git clone git@192.168.8.219:/home/git/solo.git

提交代码到 Git 仓库。

[root@jenkins ~]# cp -r /root/solo-2.9.1/* solo/

[root@jenkins ~]# cd solo

[root@jenkins solo]# git add .

[root@jenkins solo]# git config --global user.email "kgc@kgc.com"

[root@jenkins solo]# git config --global user.name "kgc"

[root@jenkins solo]# git commit -m "a"

创建标签。

[root@jenkins solo]# git tag 1.0.0

推送到 Git 服务器。

[root@jenkins solo]# git push origin 1.0.08. Jenkins 创建项目并发布测试

在 Jenkins 首页面中，选择“新建任务”并输入任务名称，构建一个 Maven 项目，如图

4.18 所示。

图 4.18 创建项目

注意：如果没有显示“构建一个 Maven 项目”选项，需要在管理插件里安装“Maven

Integration ”插件。

配置 Git 参数化构建，在“添加参数”下拉框中选择“Git 参数”，如图 4.19 所示。

图 4.19 配置 Git 参数

动态获取 Git 仓库 Tag，与用户交互，选择标签发布，如图 4.20 所示。

图 4.20 获取 Git 仓库的 tag

指定项目 Git 仓库地址，如图 4.21 所示。

图 4.21 指定仓库地址

修改*/master 为$Tag，Tag 是上面动态获取的变量名，表示根据用户选择代码版本，如

图 4.22 所示。

图 4.22 选择仓库 Tag

利用 pom.xml 文件构建项目。设置 Maven 构建命令选项，“Goals and options”配置内

容为“clean package -Dmaven.test.skip=true”，如图 4.23 所示。

图 4.23 Build 配置

pom.xml 是声明项目描述符，遵循 POM 模型版本。模型本身的版本很少改变。虽然如

此，但它仍然是必不可少的，这是为了当 Maven 引入新的特性或者其他模型变更的时候，

确保稳定性。

在 Jenkins 本机进行镜像构建，并且推送到镜像仓库，然后使用 SSH 远程连接到 Docker

主机并使用推送的镜像创建容器，如图 4.24 所示。

图 4.24 Post Steps 配置项

选择“Post Steps”→“Add post-build step”→“执行 shell”，这样会调出第一个输入框。

选择“Post Steps”→“Add post-build step” →“Execute shell script on remote host using

ssh”，这样会调出第二个输入框。图 4.24 中的命令如下所示。

在 Jenkins 主机所执行的 Shell 命令如下所示：

REPOSITORY=192.168.8.219:5000/solo:${Tag}

cat > Dockerfile << EOF

FROM 192.168.8.219:5000/tomcat-85:latest

RUN rm -rf /usr/local/tomcat/webapps/ROOT

COPY target/*.war /usr/local/tomcat/webapps/ROOT.war

CMD ["catalina.sh", "run"]

EOF

docker build -t $REPOSITORY .

docker push $REPOSITORY

SSH 远程 Docker 主机执行的 Shell 命令如下所示：

REPOSITORY=192.168.8.219:5000/solo:${Tag}

docker rm -f blog-solo |true

docker image rm $REPOSITORY |true

docker container run -d --name blog-solo -v /usr/local/java:/usr/local/java -p 88:8080

$REPOSITORY

以上都配置完成后，单击“保存”按钮。

注意：从部署命令当中可以看到最后一行容器名称是 blog-solo，暴露宿主机端口 88，

即使用宿主机 IP:88 就可以访问 blog-solo 项目。

blog-solo 项目已配置完成后，可开始构建，如图 4.25 所示。

图 4.25 Build with Parameters 选项

选择 Tag 版本为“1.0.0”，单击“开始构建”按钮，如图 4.26 所示。

图 4.26 根据 Tag 构建项目

左下角“Build History”里面，单击第一个“#1”后面的链接，再单击“控制台输出”，可查看

控制台输出的日志信息，如图 4.27 所示。

图 4.27 编译历史选项

控制台输出项目构建成功的日志信息如下所示。

[INFO] Packaging webapp

[INFO] Assembling webapp [solo] in [/root/.jenkins/workspace/blog-solo/target/solo]

[INFO] Processing war project

[INFO] Copying webapp webResources

[/root/.jenkins/workspace/blog-solo/src/main/resources/lib/net/pusuo] to

[/root/.jenkins/workspace/blog-solo/target/solo]

[INFO] Copying webapp resources [/root/.jenkins/workspace/blog-solo/src/main/webapp]

[INFO] Webapp assembled in [2259 msecs]

[INFO] Building war: /root/.jenkins/workspace/blog-solo/target/solo.war

[INFO] ------------------------------------------------------------------------

[INFO] BUILD SUCCESS

[INFO] ------------------------------------------------------------------------

[INFO] Total time: 04:07 min

[INFO] Finished at: 2020-07-21T11:55:42+08:00

[INFO] ------------------------------------------------------------------------

//省略部分内容

1.0.0: Pulling from solo

524b0c1e57f8: Already exists

534d941c394d: Already exists

3feff4823c0b: Already exists

d2b6fee74669: Already exists

8798680a9d01: Pulling fs layer

5b2d55a240d5: Pulling fs layer

8798680a9d01: Verifying Checksum

8798680a9d01: Download complete

5b2d55a240d5: Verifying Checksum

5b2d55a240d5: Download complete

8798680a9d01: Pull complete

5b2d55a240d5: Pull complete

Digest: sha256:f84dc4fd64a0d0eb37a90ed73eaa630241a9a101033b6e17faf80ad9a86ac3a6

Status: Downloaded newer image for 192.168.8.219:5000/solo:1.0.0

75cb7eb8b0fb58c17a7c7924735e6a0ab63f863a6910f8a589918e689806db74

[SSH] completed

[SSH] exit-status: 0

Finished: SUCCESS

浏览器中输入 http://192.168.8.218:88 访问 solo 项目，如图 4.28 所示。

图 4.28 浏览器访问 solo 项目

如果出现上述页面说明 solo 博客是可以正常访问的，只是页面样式没有加载成功。如

果想正确加载样式，需要再次修改项目当中的访问地址。修改方法如下。

[root@jenkins ~]# cd solo

原始配置文件。

[root@jenkins solo]# vi src/main/resources/latke.properties

#### Server ####

# Browser visit protocol

serverScheme=http

# Browser visit domain name

serverHost=localhost

# Browser visit port, 80 as usual, THIS IS NOT SERVER LISTEN PORT!

serverPort=8080

修改过后的配置文件。

#### Server ####

# Browser visit protocol

# Browser visit domain name

serverHost=192.168.8.218

# Browser visit port, 80 as usual, THIS IS NOT SERVER LISTEN PORT!

serverPort=88

将修改提交到 Git 仓库：

[root@jenkins solo]# git add .

[root@jenkins solo]# git commit -m "config"

[root@jenkins solo]# git tag 1.0.1

[root@jenkins solo]# git push origin 1.0.1

按照前面流程再次构建，选择刚提交的 Tag，如图 4.29 所示。

图 4.29 构建 Tag 1.0.1 版本

发布成功后，再次通过浏览器访问 solo 项目：http://192.168.8.218:88，如图 4.30 所

示。

图 4.30 solo 注册页面

从图 4.30 中，可以看到成功加载样式，说明刚刚修改的代码已发布成功！

9. 发布回滚

回滚（Rollback）指的是程序或数据处理错误，将程序或数据恢复到上一个正确的版本。

回滚包括程序回滚和数据回滚等类型。对于本章而言，如果当前代码版本发布失败，回滚到

上一个正常版本，尽快恢复业务。

回滚思路：重新 run 指定镜像版本。因为在每次发版过程中需要将代码封装到镜像中，

并打上 Tag，以此用来区分不同的版本。比如在发版过程中出现代码问题，需要运维工程师

快速回滚到上一个版本，这样可以做到快速恢复业务正常化。同样这个过程应该怎样实现

呢？此时，可以重新创建一个“自由风格的软件项目”，通过参数化构建特定版本，也就是指

定上一个正常版本镜像，然后重新执行创建容器命令即可回到之前正

动态获取 Git 仓库 tag，与用户交互选择 Tag 发布，如图 4.32 所示。

图 4.32 创建参数化构建过程

指定项目 Git 仓库地址，如图 4.33 所示。

图 4.33 源码管理

SSH 远程连接到 Docker 主机创建容器，如图 4.34 所示。

图 4.34 远端主机执行 Shell 脚本

上述构建步骤内的“Command”命令如下所示。

REPOSITORY=192.168.8.219:5000/solo:${Tag}

#回滚

docker rm -f blog-solo|true

docker container run -d --name blog-solo -v /usr/local/java:/usr/local/java -p 88:8080

$REPOSITORY

回滚到上一个代码版本，如图 4.35 所示。

图 4.35 开始回滚构建操作

选择回滚代码版本号，如图 4.36 所示。

图 4.36 选择回滚版本号

回滚日志信息会在控制台输出，如图 4.37 所示。

图 4.37 控制台输出

浏览器访问 solo 项目：http://192.168.8.218:88 ，页面如图 4.38 所示。

图 4.38 浏览器回滚后界面

从上图 4.38 中，可以看到没有样式，说明回滚到上一个镜像版本成功！

4.2.4 基于 Jenkins+Git+Ansible 发布 PHP 项目

1. 部署 PHP 运行环境

PHP 是一个动态程序，负责解析 PHP-FPM 服务，而这个服务不支持静态页面处理，

第 31 页 共 41 页一般结合 Nginx 解决这个问题。Nginx 本身是一个静态 Web 服务器，并不支持解析 PHP 程

序，但它通过支持 FastCGI 接口来调用动态服务解析 PHP 程序。

当客户端请求 PHP 页面时，Nginx 通过 FastCGI 接口转发给本地 9000 端口的

PHP-FPM 子进程处理，处理完成后返回 Nginx。

（1）安装 Nginx

在 Docker 主机上，配置 Nginx 网络源，并安装 Nginx。

[root@docker ~]# vi /etc/yum.repos.d/nginx.repo

[nginx]

name=nginx repo

baseurl=http://nginx.org/packages/centos/7/$basearch/

gpgcheck=0

enabled=1

[root@docker ~]# yum install nginx -y

[root@docker ~]# systemctl start nginx && systemctl enable nginx

（2）安装 PHP

安装 PHP 依赖的第三方库。

[root@docker ~]# yum install gd-devel libxml2-devel libcurl-devel libjpeg-devel libpng-devel

gcc rsync openssl-* -y

编译安装 PHP。

[root@docker ~]# tar zxvf php-5.6.34.tar.gz

[root@docker ~]# cd php-5.6.34

[root@docker php-5.6.34]# ./configure --prefix=/usr/local/php \

--with-config-file-path=/usr/local/php/etc \

--with-mysql --with-mysqli \

--with-openssl --with-zlib --with-curl --with-gd \

--with-jpeg-dir --with-png-dir --with-iconv \

--enable-fpm --enable-zip --enable-mbstring

[root@docker php-5.6.34]# make -j 4 && make install

[root@docker php-5.6.34]# cp php.ini-production /usr/local/php/etc/php.ini

配置 php-fpm。

[root@docker

php-5.6.34]#

cp

/usr/local/php/etc/php-fpm.conf.default

/usr/local/php/etc/php-fpm.conf

[root@docker php-5.6.34]# vim /usr/local/php/etc/php-fpm.conf

user = nginx

group = nginx

[root@docker php-5.6.34]# cp sapi/fpm/init.d.php-fpm /etc/init.d/php-fpm

[root@docker php-5.6.34]# chmod +x /etc/rc.d/init.d/php-fpm

[root@docker php-5.6.34]# /etc/init.d/php-fpm start

（3）Nginx 代理 PHP

添加虚拟主机配置。

[root@docker ~]# vi /etc/nginx/conf.d/default.conf

server {

listen

80;

server_name localhost;

access_log /var/log/nginx/host.access.log main;

location / {

root

/usr/share/nginx/html/blog-wordpress;

index index.php index.html index.htm;

}

location ~ \.php$ {

root

/usr/share/nginx/html/blog-wordpress;

fastcgi_pass

127.0.0.1:9000;

fastcgi_index index.php;

fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;

include

fastcgi_params;

}

}

2. 安装 Ansible 插件

在 Jenkins 首页，选择“系统管理”→“插件管理”，如图 4.39 所示。

图 4.39 进入插件管理配置

安装 Ansible 插件，如图 4.40 所示。

图 4.40 Ansible 插件安装

只在 Jenkins 中安装 Ansible 插件是不行的，还要在 Jenkins 主机上安装 Ansible。

[root@jenkins ~]# yum -y install epel-release

[root@jenkins ~]# yum install ansible -y

[root@jenkins ~]# vim /etc/ansible/hosts

//配置 Ansible 管理的主机

[webservers]

192.168.8.218

[webservers]表示 Web 主机分组名称，该分组下可以写多个主机，也可以写多个分组用

于区分不同的服务器角色。

3. 上传 PHP 项目代码到 Git 仓库

（1）在 Git 服务器创建 WordPress 版本仓库

[root@repository ~]# su - git

[root@repository ~]# mkdir wordpress.git

[root@repository ~]# cd wordpress.git

[root@repository ~]# git --bare init

（2）下载开源 PHP 博客系统 WordPress

[root@jenkins ~]# tar zxf wordpress.tar.gz

[root@jenkins ~]# cd wordpress

（3）提交到 Git 仓库

[root@jenkins wordpress]# git init

[root@jenkins wordpress]# git remote add origin git@192.168.8.219:/home/git/wordpress.git

[root@jenkins wordpress]# git add .

[root@jenkins wordpress]# git commit -m "wp"

[root@jenkins wordpress]# git tag 1.0.0

[root@jenkins wordpress]# git push origin 1.0.0

（4）做无密码验证

[root@jenkins ~]# ssh-copy-id 192.168.8.218

//上个实验已经生成了秘钥

4. Jenkins 创建项目并发布测试

在 Jenkins 首页，选择“新建任务”，并进行如图 4.41 所示配置。

图 4.41 创建自由风格项目 blog-wordpress

动态获取 Git 仓库 Tag，与用户交互选择 Tag 发布，如图 4.42 所示。

图 4.42 参数化构建过程

指定项目 Git 仓库地址，并修改*/master 为$Tag。Tag 是上面动态获取的变量名，表示

根据用户选择打代码版本，如图 4.43 所示。

图 4.43 Git 源码仓库配置

使用 Ansible 插件，选择“构建”→“增加构建步骤”→“Invoke Ansible Ad-Hoc Command”，

如图 4.44 所示。

图 4.44 选择调用 Ansible Ad-Hoc 命令配置

使用 synchronize 模块同步数据，如图 4.45 所示。

图 4.45 synchronize 模块同步数据

图 4.45 中，相关参数说明：

 Host pattern：指定刚在/etc/ansible/hosts 中定义的主机分组名称；

 Inventory：主机清单；

 Module：模块名；

 Module arguments or command to execute：模块参数或执行命令。

模块参数的具体命令，如下所示。

src=${WORKSPACE} dest=/usr/share/nginx/html rsync_opts=--exclude=.git

单击“保存”后，返回项目页面。单击“Build with Parameters”选项，选中“1.0.0”Tag。然

后，单击“开始构建”按钮，如图 4.46 所示。

图 4.46 Git 参数构建

控制台输出项目构建日志信息，如图 4.47 所示。

图 4.47 项目构建日志

需要注意的是，在访问 wordpress 之前需要校正一下权限。

[root@docker ~]# chmod 755 -R /usr/share/nginx/html/blog-wordpress/

浏览器访问 wordpress 项目：http://192.168.8.218/wp-admin 页面如图 4.48 所示。

图 4.48 WordPress 欢迎页面

由于在实施过程中并没有安装 MySQL 数据库，所以在访问 WordPress 的 wp-admin

页面时会有需要加载数据库的提示 。

模拟实际生产环境提交代码，其目的是为了可以清楚看到两次发版代码的不同。

[root@jenkins ~]# cd wordpress

[root@jenkins ~]# echo “Hello Wordpress” > test.html

将修改的 test.html 提交到 Git 仓库。

[root@jenkins wordpress]# git add .

[root@jenkins wordpress]# git commit -m "hello"

[root@jenkins wordpress]# git tag 1.0.1

[root@jenkins wordpress]# git push origin 1.0.1

在 Jenkins 执行构建任务，如图 4.49 所示。

图 4.49 构建 1.0.1 版本

还是需要校正访问权限，命令如下：

[root@docker ~]# chmod 755 -R /usr/share/nginx/html/blog-wordpress/

发布成功后，再访问:http://192.168.8.218/test.html，页面显示“Hello Wordpress!”，说

明刚修改的代码已发布成功！