jenkins + docker + SpringBoot

xzkwuli

已于 2022-06-13 18:09:59 修改

阅读量1.1k

点赞数

文章标签： jenkins docker spring boot

于 2022-05-07 22:38:27 首次发布

本文链接：https://blog.csdn.net/xzkwuli/article/details/124545190

版权

使用jenkins打包项目到容器，并使用docker启动

一、环境搭建

1、安装JDK

下载linux环境的jdk（Oracle官网下载）
将下载好的jdk压缩包放到服务器/虚拟机并解压
配置系统环境变量

vi /etc/profile
# 在文件末端添加以下内容
export JAVA_HOME=jdk安装目录
export JRE_HOME=${JAVA_HOME}/jre
export CLASSPATH=.:${JAVA_HOME}/lib:${JRE_HOME}/lib
export PATH=${JAVA_HOME}/bin:$PATH

# 输入完成后保存并推出，重新加载配置文件
source /etc/profile

# 验证是否安装成功，输出正确版本号即安装成功
java -version

2、安装MAVEN

下载linux版本的maven
解压到相应的目录
配置环境变量

vi /etc/profile

#　在文件末端添加以下配置
export MAVEN_HOME=maven安装路径
export PATH=${MAVEN_HOME}/bin:$PATH

# 重新加载配置文件
source /etc/profile

# 验证是否安装成功，输出版本号即成功
mvn -v

项目的pom文件中会使用到docker的build插件，需要在maven的settings.xml配置文件中添加pluginGroup

<pluginGroup>com.spotify</pluginGroup>

3、安装GIT

检查是否已安装git

git --version

安装git依赖

yum install curl-devel expat-devel gettext-devel openssl-devel zlib-devel asciidoc

yum install  gccel zlib-devel gcc perl-ExtUtils-MakeMaker

下载git安装用的压缩包
解压到自定义的安装目录
进入到安装目录执行以下命令编译

make install

编译完成后可使用git --version 查看版本号
git可执行文件位置：/usr/bin/git

4、安装TOMCAT

下载linux版的tomcat压缩包，解压即可

5、安装jenkins

使用tomcat启动jenkins
在官网下载war包版的 jenkins
将war放入tomcat中，启动tomcat即可
如果是放在linux 环境，需要开放对应的端口

# 查看想开的端口是否已开：
firewall-cmd --query-port=6379/tcp
# 添加指定需要开放的端口：
firewall-cmd --add-port=8080/tcp --permanent
# 重载入添加的端口：
firewall-cmd --reload
# 查询指定端口是否开启成功：
firewall-cmd --query-port=8080/tcp
# 移除指定端口：
firewall-cmd --permanent --remove-port=8080/tcp

访问jenkins：ip:port/jenkins
访问后首先会有一个解锁界面，需要输入密码，这个密码可在tomcat的日志文件中查看，或者根据页面上的提示查看指定文件也可
解锁之后创建用户
安装默认插件
进入jenkins后找到系统全局配置，将前面安装好的JDK、MAVEN、GIT都配置在jenkins，配置位置：系统配置->全局工具配置
安装Publish Over SSH插件

7、项目代码

码云地址

二、jar 包部署

1、使用jenkins新建一个任务

1.1 新建任务

在这里插入图片描述

1.2 输入任务名，选择构建一个自由…

在这里插入图片描述

1.3 进入配置界面

在这里插入图片描述

1.4 这里使用git，输入仓库地址以及分支

在这里插入图片描述

1.5 这里新增两个构建步骤，maven和shell脚本

在这里插入图片描述
shell脚本如下

mvn docker:build
echo "当前docker 镜像："
docker images | grep productmanagement
echo "启动容器----->"
docker run -p 8001:8001 -d productmanagement
echo "启动服务成功！"

2、项目代码

2.1 项目中新增Dockerfile

Dockerfile如下，基于openjdk:8 构建镜像

FROM hub.c.163.com/dwyane/openjdk:8
VOLUME /tmp
ADD productmanagement.jar app.jar
ENTRYPOINT ["java","-Djava.security.egd=file:/dev/./urandom","-jar","/app.jar"]

2.2 添加docker插件

<plugin>
	<groupId>com.spotify</groupId>
	<artifactId>docker-maven-plugin</artifactId>
	<version>1.0.0</version>
	<configuration>
		<!-- 镜像名称 -->
		<imageName>productmanagement</imageName>
		<imageTags>
			<imageTag>latest</imageTag>
		</imageTags>
		<!-- Dokcerfile 位置 -->
		<dockerDirectory>${project.basedir}/src/main/docker</dockerDirectory>
		<resources>
			<resource>
				<targetPath>/</targetPath>
				<directory>${project.build.directory}</directory>
				<include>${project.build.finalName}.jar</include>
			</resource>
		</resources>
	</configuration>
</plugin>

1.7 在jenkins中找到对应的任务，点击立即构建，即可开始

三、war 包部署

1、先构建一个基于Java8的tomcat镜像

在这里插入图片描述

这几个文件都放到同一个目录下
jdk和tomcat的压缩包可在各自的官网进行下载
Dockerfile内容如下

FROM         centos:7
MAINTAINER    wulitou

#把java与tomcat添加到容器中
ADD jdk-8u291-linux-x64.tar.gz /usr/local/
ADD apache-tomcat-9.0.59.tar.gz /usr/local/

# 添加自定义的tomcat启动脚本（解决没有catalina.out日志文件的问题）
ADD run.sh /usr/local/


#配置java与tomcat环境变量
ENV JAVA_HOME /usr/local/jdk1.8.0_291
ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
ENV CATALINA_HOME /usr/local/apache-tomcat-9.0.59
ENV CATALINA_BASE /usr/local/apache-tomcat-9.0.59
ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/lib:$CATALINA_HOME/bin

#容器运行时监听的端口
EXPOSE  8080

CMD ["/usr/local/run.sh"]

# 使用catalina.sh 启动tomcat，会导致在logs目录下不生成catalina.out日志文件，不便于查看运行日志
# CMD ["catalina.sh", "run"]

run.sh内容如下，构建镜像前，需要调整run.sh文件的操作权限(chmod 777 run.sh)，否则会因为没有run.sh的操作权限导致在启动容器时失败

#!/bin/bash
# 使用startup.sh启动tomcat
bash /usr/local/apache-tomcat-9.0.59/bin/startup.sh
tail -f /usr/local/apache-tomcat-9.0.59/logs/catalina.out

最后执行docker build -t tomcat-wulitou:v1 .构建名称是tomcat-wulitou，版本是v1的镜像

2、新建一个任务，具体过程参考jar包的任务

构建maven时，需要在高级->pom中输入准确的pom文件位置
项目结构如下
新增的shell脚本如下

echo "杀掉tomcat进程"
tomcat_id=$(ps -ef |grep tomcat |grep -w tomcat-automatic|grep -v 'grep' |awk {'print $2'})
if [$tomcat_id -ne 0]
then
kill -9 $tomcat_id
else
echo "tomcat-automatic 未启动"
fi

# 构建成功后也放一份war到宿主机上的tomcat中
cd /usr/local/tomcat/tomcat-automatic/webapps
rm -rf automatic-code-generation
rm -rf automatic-code-generation.war
cp /root/.jenkins/workspace/automaticcodegeneration/automatic-code-generation-parent/automatic-code-generation-controller/target/automatic-code-generation.war ./
echo "启动tomcat-automatic"
sh /usr/local/tomcat/tomcat-automatic/bin/startup.sh

echo "删除现有容器"
docker stop codegeneration
docker rm codegeneration

echo "删除现有镜像"
docker rmi automatic-code-generation

# 由于我是用tomcat启动jenkins，所以jenkins构建项目成功后，会将可执行文件存放在/root/.jenkins/workspace/ 目录
cd /root/.jenkins/workspace/automaticcodegeneration/automatic-code-generation-parent/automatic-code-generation-controller
echo "开始构建镜像"
mvn docker:build
echo "当前docker镜像"
docker images
echo "启动镜像"
docker run --name codegeneration -p 8084:8080 -d automatic-code-generation

3、项目代码

3.1 新增Dockerfile

基于 1 创建的tomcat镜像进行构建

#基础镜像
FROM tomcat-wulitou:v1
#作者信息
MAINTAINER xzk_wulitou@163.com
#定义变量，具体路径可以自行启动一个测试容器然后进入进行查看
ENV DIR_WEBAPP /usr/local/apache-tomcat-9.0.59/webapps/
#添加本地的war包到远程容器中
ADD ./target/automatic-code-generation.war $DIR_WEBAPP
#配置工作目录
WORKDIR /usr/local/apache-tomcat-9.0.59/webapps
#暴露端口
EXPOSE 8080

3.2 添加插件

<build>
		<plugins>
			<plugin>
				<artifactId>maven-war-plugin</artifactId>
				<configuration>
					<!--如果想在没有web.xml文件的情况下构建WAR，请设置为false。-->
					<failOnMissingWebXml>false</failOnMissingWebXml>
				</configuration>
			</plugin>

			<!--使用docker-maven-plugin插件-->
			<plugin>
				<groupId>com.spotify</groupId>
				<artifactId>docker-maven-plugin</artifactId>
				<version>1.0.0</version>

				<!--将插件绑定在某个phase执行-->
				<executions>
					<execution>
						<id>build-image</id>
						<!--将插件绑定在package这个phase上。也就是说，
                        用户只需执行mvn package ，就会自动执行mvn docker:build-->
						<phase>package</phase>
						<goals>
							<goal>build</goal>
						</goals>
					</execution>
				</executions>

				<configuration>
					<!--指定生成的镜像名,这里是我们的项目名-->
					<imageName>${project.artifactId}</imageName>
					<!--指定标签 这里指定的是镜像的版本，我们默认版本是latest-->
					<imageTags>
						<imageTag>latest</imageTag>
					</imageTags>
					<!-- 指定我们项目中Dockerfile文件的路径-->
					<dockerDirectory>${project.basedir}</dockerDirectory>

					<baseImage>williamyeh/java8</baseImage>

					<!-- 这里是复制 war 包到 docker 容器指定目录配置 -->
					<resources>
						<resource>
							<targetPath>/</targetPath>
							<!--jar包所在的路径  此处配置的即对应项目中target目录-->
							<directory>${project.build.directory}</directory>
							<!-- 需要包含的 jar包 ，这里对应的是 Dockerfile中添加的文件名　-->
							<include>${project.build.finalName}.war</include>
						</resource>
					</resources>
				</configuration>
			</plugin>
		</plugins>
		<finalName>automatic-code-generation</finalName>
	</build>

四、使用docker-compose部署

1、安装docker社区版

1.1、卸载清除原来的docker

yum remove docker \
                  docker-client \
                  docker-client-latest \
                  docker-common \
                  docker-latest \
                  docker-latest-logrotate \
                  docker-logrotate \
                  docker-engine

1.2、下载需要的安装包

yum install -y yum-utils

1.3、设置aliyun镜像仓库

yum-config-manager \
    --add-repo \
    https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

1.4、更新yum软件包索引

yum makecache fast

1.5、查看可安装的社区版版本号

yum list docker-ce --showduplicates | sort -r

在这里插入图片描述

1.6、开始安装社区版

# 默认最新
yum install docker-ce docker-ce-cli containerd.io
# 选择指定版本安装
sudo yum install docker-ce-20.10.13 docker-ce-cli-20.10.13 containerd.io

2、安装docker-compose

2.1、下载

https://github.com/docker/compose/releases/tag/1.25.5
在这里插入图片描述

将文件上传到 /usr/local/bin 目录，并重命名为docker-compose
执行命令赋予可执行权限sudo chmod +x /usr/local/bin/docker-compose
查看版本号docker-compse --version
创建软链sudo ln -s /usr/local/bin/docker-compose /usr/bin/docker-compose

2.2、使用

docker-compose.yml

version: "3.8"
services: 
  code_generation: 
    container_name: code-generation
    build:
      context: ./
      # 指定dockerfile文件路径
      dockerfile: code-generation/Dockerfile
    ports:
    # 映射端口
      - "8081:8080"
    # 文件挂载
    volumes:
      - code-generation-webapps:/usr/local/apache-tomcat-9.0.59/webapps
      - code-generation-conf:/usr/local/apache-tomcat-9.0.59/conf
      - code-generation-logs:/usr/local/apache-tomcat-9.0.59/logs
    environment:
      TZ: Asia/Shanghai  #指定时区
    restart: always
    networks:
      - code-generation
volumes: 
  code-generation-webapps:
    name: code-generation-webapps
  code-generation-conf:
    name: code-generation-conf
  code-generation-logs:
    name: code-generation-logs
networks:
  code-generation:
    name: code-generation

Dockerfile

#基础镜像
FROM tomcat-wulitou:v1
#作者信息
MAINTAINER xzk_wulitou@163.com
#定义变量，具体路径可以自行启动一个测试容器然后进入进行查看
ENV DIR_WEBAPP /usr/local/apache-tomcat-9.0.59/webapps/
#配置工作目录
WORKDIR /usr/local/apache-tomcat-9.0.59/webapps
#暴露端口
EXPOSE 8080

在docker-compose.yml文件所在目录执行命令docker-compose up构建镜像，运行容器
此时可在/var/lib/docker/volumes 目录下查看到挂载的目录

3、项目代码调整

pom.xml，去掉docker插件

<build>
		<plugins>
			<plugin>
				<artifactId>maven-war-plugin</artifactId>
				<configuration>
					<!--如果想在没有web.xml文件的情况下构建WAR，请设置为false。-->
					<failOnMissingWebXml>false</failOnMissingWebXml>
				</configuration>
			</plugin>

			<!--使用docker-maven-plugin插件-->
<!--			<plugin>-->
<!--				<groupId>com.spotify</groupId>-->
<!--				<artifactId>docker-maven-plugin</artifactId>-->
<!--				<version>1.0.0</version>-->

<!--				&lt;!&ndash;将插件绑定在某个phase执行&ndash;&gt;-->
<!--				<executions>-->
<!--					<execution>-->
<!--						<id>build-image</id>-->
<!--						&lt;!&ndash;将插件绑定在package这个phase上。也就是说，-->
<!--                        用户只需执行mvn package ，就会自动执行mvn docker:build&ndash;&gt;-->
<!--						<phase>package</phase>-->
<!--						<goals>-->
<!--							<goal>build</goal>-->
<!--						</goals>-->
<!--					</execution>-->
<!--				</executions>-->

<!--				<configuration>-->
<!--					&lt;!&ndash;指定生成的镜像名,这里是我们的项目名&ndash;&gt;-->
<!--					<imageName>automatic-code-generation</imageName>-->
<!--					&lt;!&ndash;指定标签 这里指定的是镜像的版本，我们默认版本是latest&ndash;&gt;-->
<!--					<imageTags>-->
<!--						<imageTag>latest</imageTag>-->
<!--					</imageTags>-->
<!--					&lt;!&ndash; 指定我们项目中Dockerfile文件的路径&ndash;&gt;-->
<!--					<dockerDirectory>${project.basedir}</dockerDirectory>-->

<!--					<baseImage>williamyeh/java8</baseImage>-->

<!--					&lt;!&ndash; 这里是复制 jar 包到 docker 容器指定目录配置 &ndash;&gt;-->
<!--					<resources>-->
<!--						<resource>-->
<!--							<targetPath>/</targetPath>-->
<!--							&lt;!&ndash;jar包所在的路径  此处配置的即对应项目中target目录&ndash;&gt;-->
<!--							<directory>${project.build.directory}</directory>-->
<!--							&lt;!&ndash; 需要包含的 jar包 ，这里对应的是 Dockerfile中添加的文件名　&ndash;&gt;-->
<!--							<include>${project.build.finalName}.war</include>-->
<!--						</resource>-->
<!--					</resources>-->
<!--				</configuration>-->
<!--			</plugin>-->
		</plugins>
		<finalName>automatic-code-generation</finalName>
	</build>

4、jenkins配置调整

调整shell脚本

echo "删除原来的war包"
rm -rf /var/lib/docker/volumes/code-generation-webapps/_data/ROOT.war
rm -rf /var/lib/docker/volumes/code-generation-webapps/_data/ROOT
echo "复制war包到挂载目录"
cd /root/.jenkins/workspace/automaticcodegeneration/automatic-code-generation-parent/automatic-code-generation-controller/target/
cp automatic-code-generation.war  /var/lib/docker/volumes/code-generation-webapps/_data/ROOT.war
echo "复制完成"

xzkwuli

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
5
评论
jenkins + docker + SpringBoot

使用jenkins打包项目到容器，并使用docker启动1、安装JDK下载linux环境的jdk（Oracle官网下载）将下载好的jdk压缩包放到服务器/虚拟机并解压配置系统环境变量vi /etc/profile# 在文件末端添加以下内容export JAVA_HOME=jdk安装目录export JRE_HOME=${JAVA_HOME}/jreexport CLASSPATH=.:${JAVA_HOME}/lib:${JRE_HOME}/libexport PATH=${..
复制链接

扫一扫