微服务容器部署与持续集成（Jenkins）_java微服务项目使用jenkins流程化部署

 
本博客使用的服务器是虚拟机centos7服务器，IP地址为192.168.48.130，下面会多次使用该IP地址。

相关文件链接：https://pan.baidu.com/s/19gZorjsyqaG3aVS3hGJGuQ
提取码：y964
 

一、微服务容器部署

 
微服务容器部署有两种方式：

• 手动部署：首先基于源码打包生成jar包（或war包）,将jar包（或war包）上传至虚拟机并拷贝至JDK容器。
• 自动部署：通过DockerMaven插件自动部署。

对于数量众多的微服务，手动部署是非常麻烦的做法，并且容易出错，所以本博客使用自动部署方式。
 

1、Dockerfile

 

1.1 Dockerfile简介

 
Dockerfile是由一系列命令和参数构成的脚本，这些命令应用于基础镜像并最终创建一个新的镜像。

常用命令：

 

1.2 使用脚本创建镜像

 
因为工程需要用到jdk，所以需要先创建一个jdk镜像。

步骤：
（1）在linux中创建目录。

mkdir –p /usr/local/dockerjdk8
1

（2）下载 jdk-8u171-linux-x64.tar.gz 并上传到服务器中的/usr/local/dockerjdk8目录。

（3）在/usr/local/dockerjdk8目录下创建Dockerfile文件 。

vi Dockerfile
1

Dockerfile文件内容：

#依赖镜像名称和ID
FROM centos:7
#指定镜像创建者信息
MAINTAINER SULONG
#切换工作目录
WORKDIR /usr
RUN mkdir /usr/local/java
#ADD 是相对路径jar,把java添加到容器中
ADD jdk-8u171-linux-x64.tar.gz /usr/local/java/
#配置java环境变量
ENV JAVA_HOME /usr/local/java/jdk1.8.0_171
ENV JRE_HOME $JAVA_HOME/jre
ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar:$JRE_HOME/lib:$CLASSPATH
ENV PATH $JAVA_HOME/bin:$PATH
1
2
3
4
5
6
7
8
9
10
11
12
13
14

点击按键i进入编辑模式，输入Dockerfile文件内容。

点击按键esc退出编辑模式，进入命令模式。

输入:wq退出并保存文本。

（4）执行命令构建镜像。

docker build -t='jdk1.8' .
1

注意命令后末尾的空格和点，.表示在当前目录，jdk表示镜像名称。

（5）查看镜像是否创建完成。

docker images
1

（6）创建容器。

docker run -di --name=tensquare_jdk jdk1.8
1

（7）查看容器是否创建完成。

docker ps
1

 

2、Docker私有仓库

 

2.1 私有仓库搭建与配置

 
（1）拉取私有仓库镜像。

docker pull registry
1

（2）启动私有仓库容器。

docker run -di --name=registry -p 5000:5000 registry
1

（3）打开浏览器，输入地址 http://192.168.48.130:5000/v2/_catalog ，看到 {"repositories":[]} 表示私有仓库搭建成功，并且包含的镜像为空。

 

2.2 镜像上传至私有仓库

 
（1）向docker中传镜像，需要让docker信任私有仓库地址。

修改daemon.json。

vi /etc/docker/daemon.json
1

添加以下内容，保存退出：

• 配置docker所有镜像的下载地址（https://docker.mirrors.ustc.edu.cn为中国的服务器）：

{"registry-mirrors": ["https://docker.mirrors.ustc.edu.cn"]}
1

• 配置docker信任私有仓库地址：

{"insecure-registries": ["192.168.48.130:5000"]}
1

重启docker 服务。

systemctl restart docker
1

（2）标记此镜像为私有仓库的镜像。

docker tag jdk1.8 192.168.48.130:5000/jdk1.8
1

（3）再次启动私有仓库容器。

docker start registry
1

（4）上传标记的镜像。

docker push 192.168.48.130:5000/jdk1.8
1

（5）打开浏览器，输入地址 http://192.168.48.130:5000/v2/_catalog，可以看到刚上传的镜像的名称。

 

3、DockerMaven插件自动部署

 
Maven插件自动部署步骤：

（1）修改服务器的docker配置，让其可以远程访问。

vi /lib/systemd/system/docker.service
1

其中ExecStart=后添加配置

-H tcp://0.0.0.0:2375 -H unix:///var/run/docker.sock
1

• unix://var/run/docker.sock：unix socket，本地客户端将通过这个来连接 Docker Daemon。

• tcp://0.0.0.0:2375：tcp socket，表示允许任何远程客户端通过 2375 端口连接 Docker Daemon。

（2）刷新配置，重启docker服务，启动私有仓库容器。

• 刷新配置命令：

systemctl daemon-reload 
1

• 重启docker服务命令：

systemctl restart docker 
1

• 启动私有仓库容器命令：

docker start registry
1

（3）在微服务工程的 pom.xml 增加配置（插件信息）。

pom.xml文件可以放三种信息：工程本身的信息、使用的第三方jar包信息、插件信息。

	<!--配置实用docker的Maven自动部署插件,配置的是内网ip-->
    <build>
        <finalName>app</finalName>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
            <!--docker的maven插件，官网：https://github.com/spotify/docker-maven-plugin-->
            <plugin>
                <groupId>com.spotify</groupId>
                <artifactId>docker-maven-plugin</artifactId>
                <version>0.4.13</version>
                <configuration>
                    <!--配置私有仓库的位置,根据实际情况填写,访问地址要能被访问到-->
                    <imageName>192.168.48.130:5000/${project.artifactId}:${project.version}</imageName>
                    <baseImage>jdk1.8</baseImage>
                    <entryPoint>["java","-jar","/${project.build.finalName}.jar"]</entryPoint>
                    <resources>
                        <resource>
                            <targetPath>/</targetPath>
                            <directory>${project.build.directory}
                            </directory>
                            <include>${project.build.finalName}.jar</include>
                        </resource>
                    </resources>
                    <dockerHost>http://192.168.48.130:2375</dockerHost>
                </configuration>
            </plugin>
        </plugins>
    </build>
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

以上配置会自动生成Dockerfile，如下：

FROM jdk1.8
ADD app.jar /
ENTRYPOINT ["java","‐jar","/app.jar"]
1
2
3

（4）启动微服务工程的application.yml中使用的相关docker容器，例如：mysql、rabbitMq、redis等等。

（5）在windows的命令提示符下，进入微服务工程所在的目录，输入以下
命令进行打包和上传镜像（需要配置Maven环境变量）。

mvn clean package docker:build -DpushImage
1

执行后，会有如下输出：

浏览器访问 http://192.168.48.130:5000/v2/_catalog ，出现微服务工程的镜像。

（6）进入服务器查看微服务工程的镜像。

docker images
1

（7） 启动微服务工程容器：

docker run -di --name=tensquare_config -p 12000:12000 192.168.48.130:5000/tensquare_config:1.0-SNAPSHOT
1

（8）访问微服务工程的服务（这里的微服务是Spring Cloud Config）。

 

二、持续集成

 
持续集成（Continuous integration）简称CI，持续集成中的任何一个环节都是自动完成的，无需太多的人工干预，有利于减少重复过程以节省时间、费用和工作量。

特点：

• 持续集成是一个自动化的周期性的集成测试过程，从检出代码、编译构建、运行测试、结果记录、测试统计等都是自动完成的，无需人工干预;
• 需要有专门的集成服务器来执行集成构建；
• 需要有代码托管工具（GitLab、GitHub、Gitee等Git平台）支持；

本博客运用Jenkins实现持续集成，使用的集成服务器是虚拟机centos7服务器（IP地址为192.168.48.130），使用的代码托管工具是Gogs。
 

1、Gogs代码托管平台

 
Gogs 是一款极易搭建的自助 Git 服务。Gogs 的目标是打造一个最简单、最快速和最轻松的方式搭建自助 Git 服务。使用 Go 语言开发使得 Gogs 能够通过独立的二进制分发，并且支持 Go 语言支持的所有平台，包括 Linux、Mac OS X、Windows 以及 ARM 平台。

官方网址：https://gogs.io/
 

1.1 Gogs的安装与启动

 
（1）下载Gogs镜像。

docker pull gogs/gogs
1

（2）创建Gogs容器。

docker run -di --name=gogs -p 10022:22 -p 3000:3000 -v /var/gogsdata:/data gogs/gogs
1

注意：启动容器后，Gogs服务一直访问不了，可以通过docker ps命令查看Gogs容器的状态。如果Gogs容器的状态一直为（health：starting）或者（unhealthy）的话，则可以通过systemctl status docker查看监听日志。

监听日志出现提示没有权限：mkdir: can't create directory '/data/git/': Permission denied，可能是SELINUX阻止的原因，关闭SELINUX即可解决。

解决方法：

1.临时关闭：

setenforce 0
1

2.永久关闭SELINUX（选择此方法需要慎重）：

注意：如果选择此方法，则在文件中SELINUX为enforcing之前创建的全部容器重新启动时都会报错而启动失败，需要将这些容器通过镜像重新创建。

vi /etc/selinux/config
1

修改文件内容中的SELINUX为disabled。

修改文件内容后，删除原来的Gogs容器，使用Gogs镜像再重新创建一个Gogs容器。

 

1.2 Gogs的配置

 
（1）在地址栏输入 http://192.168.48.130:3000 会进入首次运行安装程序页面，可以选择一种数据库作为gogs数据的存储，最简单的是选择SQLite3。如果对于规模较大的公司，可以选择MySQL。SQLite3为Gogs自带，不需要额外安装，而其他数据库则需要额外进行安装。

这里的域名要设置为centos服务器的IP地址，配置好后，点击立即安装。

（2）进入注册页面，注册管理员用户，第一个注册的用户拥有管理员权限。

（3）登录管理员账号。

（4）创建仓库。



 

1.3 IDEA配置Git

 
（1）在windows本地安装git（Windows版本）。

（2）在IDEA中选择菜单 : File – settings , 在窗口中选择Version Control -> Git。

 

1.4 将工程代码提交到Git

 
（1）配置版本控制系统：选择IDEA上方菜单栏中的VCS --> Enable Version Control Integration… ，选择Git。

（2）设置Git远程仓库地址：右键点击工程选择菜单 Git -> Repository ->Remotes…，新建一个Gogs远程仓库的别名。

（3）将工程文件添加到暂存区：右键点击工程选择菜单 Git -> Add。

（4）将工程文件提交到本地仓库：右键点击工程选择菜单 Git -> Commit Directory…。

（5）将本地仓库推送到远程仓库：右键点击工程选择菜单 Git -> Repository -> Push …。




 

2、运行Jenkins实现持续集成

 

2.1 Jenkins简介

 
Jenkins，原名Hudson，2011年改为现在的名字，它是一个开源的实现持续集成的软件工具。Jenkins 能实施监控集成中存在的错误，提供详细的日志文件和提醒功能，还能用图表的形式形象地展示项目构建的趋势和稳定性。

官方网站：https://www.jenkins.io/

特点：

• 易安装：只需要一个 java -jar jenkins.war 文件，从官网下载该文件后，直接运行，无需额外的安装，更无需安装数据库；
• 易配置：提供友好的GUI配置界面；
• 变更支持：Jenkins能从代码仓库（Subversion/CVS）中获取并产生代码更新列表并输出到编译输出信息中；
• 支持永久链接：用户是通过web来访问Jenkins的，而这些web页面的链接地址都是永久链接地址，因此可以在各种文档中直接使用该链接；
• 集成E-Mail/RSS/IM：当完成一次集成时（构建一次集成需要花费一定时间），可通过这些工具实时告诉你集成结果；
• JUnit/TestNG测试报告：以图表等形式提供详细的测试报表功能；
• 支持分布式构建：Jenkins可以把集成构建等工作分发到多台计算机中完成；
• 文件指纹信息：Jenkins会保存哪次集成构建产生了哪些jars文件，哪一次集成构建使用了哪个版本的jars文件等构建记录；
• 支持第三方插件：使得 Jenkins 变得越来越强大。
   

2.2 安装Jenkins

 
2.357以前的Jenkins版本支持的JDK环境是JDK8和JDK11，而2.357及其以后的Jenkins版本支持的JDK环境是JDK11和JDK17。

本博客使用的是JDK环境是JDK8，使用的Jenkins版本是2.356。

下载Jenkins的rpm包不建议使用官方网站的镜像站，建议使用清华园的镜像站：https://mirrors.tuna.tsinghua.edu.cn/jenkins/redhat/jenkins-2.356-1.1.noarch.rpm

 

2.2.1 安装JDK环境

 
（1）将jdk-8u171-linux-x64.rpm安装包上传至服务器。

（2）执行安装命令。

rpm -ivh jdk-8u171-linux-x64.rpm
1

RPM方式安装JDK，其根目录为：/usr/java/jdk1.8.0_171t。
 

2.2.2 Jenkins的安装与启动

 
（1）将jenkins-2.356-1.1.noarch.rpm安装包上传至服务器。

（2）安装jenkins。

rpm ‐ivh jenkins-2.356-1.1.noarch.rpm
1

（3）修改配置文件。

vi /usr/lib/systemd/system/jenkins.service
1

修改Jenkins的端口号为8888：

JENKINS_PORT=8888
1

（4）启动服务

systemctl start jenkins
1

注意：建议当Jenkins安装以及其插件安装都全部完成后，再重新启动Jenkins服务检查是否能正常启动成功。因为有时候第一次启动能成功，但是第二次启动有可能会失败，可以使用journalctl -xel查看具体日志信息，在 2.2.4 启动Jenkins报错时的处理 中有介绍相关报错的处理方法。

（5）在浏览器中访问地址 http://192.168.48.130:8888，进入Jenkins中，此时需要解锁Jenkins。

需要从/var/lib/jenkins/secrets/initialAdminPassword中获取初始密码串。

cat /var/lib/jenkins/secrets/initialAdminPassword
1

输入初始密码串解锁Jenkins。

（6）安装Jenkins推荐的插件。

保证Git插件安装成功即可，其他插件安装失败没有关系，如果Git插件安装失败，则后续需要手动进行安装。这里的Git插件只是一个连接Git软件的插件。

（7）新建管理员用户。

（8）完成安装进入主界面。

 

2.2.3 安装Jenkins插件

 
（1）点击左侧的菜单中的 Manage Jenkins 系统管理，然后点击 Manage Plugins 插件管理。

（2）安装Maven插件

进入可选插件页面，搜索Maven插件，选择Maven Integration后，点击Install without restart进行安装。

（3）安装Git插件
在安装推荐插件时安装Git插件失败，或者在已安装页面搜索不到Git Plugin时，则需要像安装Maven插件一样安装Git插件（Git Plugin）。

 

2.2.4 处理启动Jenkins服务时的报错

 
报错1：如果启动Jenkins服务时，报了下图中 jenkins.service holdoff time over, scheduling restart 启动超时的错误，则需要在文件 /etc/init.d/jenkins中添加有效的java路径（前面安装的JDK8环境）。

（1）在文件 /etc/init.d/jenkins中添加有效的java路径。

vi /etc/init.d/jenkins  
1

有效的java路径：

/usr/java/jdk1.8.0_171-amd64/bin/java
1

（2）重启Jenkins服务

systemctl restart jenkins.service
1

（3）查看是否Jenkins是否启动成功

systemctl status jenkins.service
1

报错2：如果启动Jenkins服务时，报了下图中 Unregistered Authticatiom Agent for unix-process:2821:154672(system bus name :1.76， object path /org/freedesktop/PolicyKitl/Authenticatio 没有权限的错误，则需要将原来的jenkins用户修改为root用户。

注意：修改成root用户后，登录的账号将会有jenkins变成root，密码不变。

（1）修改Jenkins配置中的用户所有者和用户组为root。

vi /usr/lib/systemd/system/jenkins.service
1

修改内容：

User=root
Group=root
1
2

重新加载Jenkins配置文件。

systemctl daemon-reload
1

（2）修改Jenkins相关文件夹的用户权限，更改jenkins三个文件夹的用户所有者和用户组。

chown -R root:root /var/lib/jenkins
chown -R root:root /var/cache/jenkins
chown -R root:root /var/log/jenkins
1
2
3

（3）重启Jenkins服务。

systemctl restart jenkins.service
1

（4）查看是否Jenkins是否启动成功。

systemctl status jenkins.service
1

 

2.3 全局工具配置

 

2.3.1 安装Maven

 
（1）将Maven压缩包上传至服务器。

（2）解压apache‐maven‐3.3.9‐bin.tar.gz压缩包。

tar zxvf apache-maven-3.3.9-bin.tar.gz
1

（3）将apache‐maven-3.3.9文件夹移动到/usr/local目录下，并将文件夹重命名为maven。

mv apache‐maven-3.3.9 /usr/local/maven
1

（4）编辑setting.xml配置文件，配置本地仓库目录。

vi /usr/local/maven/conf/settings.xml
1

配置本地仓库目录：

<localRepository>/usr/local/repository</localRepository>
1

 

2.3.2 配置Maven仓库

 
（1）如果工程中有工具模块，工具模块不会有Docker容器，到时候使用的是工具模块的Jar包，需要使用Maven Install在maven仓库中生成Jar包。


如果工具模块的pom.xml文件中有导入父工程的依赖，则也需要使用Maven Install在maven仓库中生成Jar包，父工程install的话，会生成所有模块的Jar包，最后只要保留父工程和工具类的Jar包即可。


将开发环境的本地Maven仓库上传至服务器，并移动到/usr/local目录下，文件夹名称为repository。

mv repository /usr/local/repository
1

执行此步是为了以后在打包的时候不必重新下载Maven依赖，缩短打包的时间。
 

2.3.3 全局工具配置

 
让Jenkins通过相关插件去连接需要的软件（Git、Maven、JDK）。

（1）选择系统管理 -> 全局管理工具。

（2）配置JDK软件（使用已经安装好的JDK8）：点击取消自动安装，设置别名为JDK，JAVA_HOME为 /usr/java/jdk1.8.0_171-amd64。

（3）配置Git软件：Centos7本地已经安装了Git软件，使用默认即可。

（4）配置Maven软件（使用已经安装好的Maven）：点击取消自动安装，设置别名为Maven，MAVEN_HOME为 /usr/local/maven。

（5）点击保存。

 

2.4 持续集成

 

2.4.1 创建任务

 
（1）在首页点击菜单中的新建Item，输入任务名称（微服务模块名称），选择创建一个Maven项目，点击确定按钮。

（2）在源码管理中，选择Git，并输入gogs的工程仓库的http链接。

（3）在Build中输入要创建镜像的微服务模块的pom.xml位置和需要执行的Maven命令。

maven命令（用于清除、打包、构建docker镜像）:

clean package docker:build -DpushImage
1

（4）点击保存按钮。

（5）工程中微服务模块的配置。
到需要构建镜像的微服务模块的 pom.xml 增加docker插件信息配置（与上面的DockerMaven插件自动部署中的配置内容一致）。

本案例使用的Spring Cloud Config配置中心，所以需要将bootstrap.yml中的本地tensqure_config配置中心的地址改成服务器中tensqure_config配置中心容器的地址（tensqure_config配置中心是在上面DockerMaven插件自动部署中创建的容器，也可以用Jenkins重新创建Maven任务再到服务器中使用生成的镜像创建容器）。

Git平台上的微服务模块的yml配置文件中的本地地址（localhost或者127.0.0.1）也要改成服务器地址，同时也要确保相关容器有在服务器中运行。

pom.xml 增加docker插件信息配置：

	<!--配置实用docker的Maven自动部署插件,配置的是内网ip-->
    <build>
        <finalName>app</finalName>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
            <!--docker的maven插件，官网：https://github.com/spotify/docker-maven-plugin-->
            <plugin>
                <groupId>com.spotify</groupId>
                <artifactId>docker-maven-plugin</artifactId>
                <version>0.4.13</version>
                <configuration>
                    <!--配置私有仓库的位置,根据实际情况填写,访问地址要能被访问到-->
                    <imageName>192.168.48.130:5000/${project.artifactId}:${project.version}</imageName>
                    <baseImage>jdk1.8</baseImage>
                    <entryPoint>["java","-jar","/${project.build.finalName}.jar"]</entryPoint>
                    <resources>
                        <resource>
                            <targetPath>/</targetPath>
                            <directory>${project.build.directory}
                            </directory>
                            <include>${project.build.finalName}.jar</include>
                        </resource>
                    </resources>
                    <dockerHost>http://192.168.48.130:2375</dockerHost>
                </configuration>
            </plugin>
        </plugins>
    </build>
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

修改完成后一定记得要提交推送到Git远程仓库中（因为Jenkins构建镜像的资源是从Git平台上获取的，也就是从gogs中获取的）。

 

2.4.2 执行任务

 
（1）返回首页，在列表中找到刚才创建的任务，点击右边的绿色箭头按钮，即可执行此任务。

（2）点击下面正在执行的任务，选择控制台输出。

（3）可以看到实时输出的日志。

（4）下面就是镜像构建好了在上传，如果之前没有将本地Maven仓库上传到服务器，会首先下载依赖的jar包。

（5）看到下面的结果就表示已经成功推送到服务器的docker私有仓库中了。

（6）返回首页查看任务列表（如果执行结果都是成功，图标会变成一个太阳，如果执行失败的话，图标会变成下雨）。

 

2.4.3 创建容器

 
（1）在浏览器查看docker私有仓库 http://192.168.48.130:5000/v2/_catalog，会看到tensquare_eureka镜像已经上传成功了。

（2）在服务器中启动tensquare_eureka容器。

docker run -di --name=tensquare_eureka -p 6868:6868 192.168.48.130:5000/tensquare_eureka:1.0-SNAPSHOT
1

（3）在浏览器中访问tensquare_eureka服务。