Jenkins+Gitlab+Docker（Dockerfile）部署

Docker部署运行

​ 上一篇内容中使用Jenkins(运行服务器)+Gitlab(代码存储库)+Webhook(网络钩子)的方式部署运行我们的项目。需要我们在服务器上做好很多相关的环境配置及依赖。

​ 那么假如有这样一个场景：需要把不同技术栈的项目部署到同一台服务器上运行。比如PHP、.NET、Java、Python的程序都部署到同一台服务器，那么可能由于各自依赖包及环境有冲突，或依赖软件版本不同造成无法兼容的问题。

​ 再假如，企业需要搭建一套新的服务，8台服务器，每台都需要Java运行环境、Tomcat都需要去执行安装JDK、配置环境变量、Tomcat配置等相同的流程，重复劳动。

​ 那么要避免这些问题，我们可以使用容器虚拟化技术，如Docker。Docker能使环境隔离，完美规避软件无法兼容的问题。只需要配置好一台服务器，可以把镜像上传到仓库，其他服务器直接拉取下来即可一键使用。

Docker介绍

​ Docker是一个开源项目，非常优秀的开源容器引擎，基于Google公司推出的Go语言实现。Docker能将应用程序间环境隔离，帮助用户更快交付部署，高效利用宿主机资源。Docker很适合微服务架构，单个容器运行单个程序。

​ Docker有3个基本概念：

• 镜像：镜像定义了运行容器的资源，用户可以使用Dockerfile自定义镜像，可以看作它是由一条条指令构成
• 容器：镜像运行起来，就是容器，麻雀虽小，五脏俱全，它有自己的文件系统、网络、以及各种软件，相当于是一个微型的操作系统
• 仓库：仓库主要用于存储，存储镜像的地址。可将镜像上传至仓库，也能从仓库上pull下来镜像(类似gitlab代码存储)

Docker安装

安装Docker的官方文档地址：https://docs.docker.com/engine/install/，Docker支持安装在多种操作系统上，Windows、Mac、Centos、Ubuntu等，笔者这里选择Centos。一般安装一个CE版本的就可以了。

• 使用yum安装yum-utils软件包和设置稳定的存储库

yum -y install yum-utils # 安装yum-utils
yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo  # 设置存储库
1
2

• 安装Docker CE和containerd

yum -y install docker-ce coker-ce-cli containerd.io	# 安装最新版
1

上面那条命令是安装最新版，若要安装指定版本，先列出可用的版本列表

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

选择一个版本安装

yum install docker-ce-<VERSION_STRING> docker-ce-cli-<VERSION_STRING> containerd.io # 安装指定版本，用版本号替换掉VERSION_STRING即可
1

• 安装完成后，可以启动docker了

systemctl start docker	# 启动
systemctl restart docker # 重启
systemctl stop docker	# 关闭
1
2
3

• 使用docker version看下docker是否安装完毕及版本号

Client: Docker Engine - Community
 Version:           24.0.6
 API version:       1.43
 Go version:        go1.20.7
 Git commit:        ed223bc
 Built:             Mon Sep  4 12:35:25 2023
 OS/Arch:           linux/amd64
 Context:           default

Server: Docker Engine - Community
 Engine:
  Version:          24.0.6
...
1
2
3
4
5
6
7
8
9
10
11
12
13

Docker镜像加速器

Docker的镜像默认是在Docker Hub上下载的，但是国内下载很慢，下载大镜像时问题尤为突出，甚至还会断开。我们可以使用其他的镜像源，如阿里云，只需要注册一个账号，进入镜像服务，点击镜像加速器，可以免费获取一个镜像加速的地址。

命令贴到这里

sudo mkdir -p /etc/docker
sudo tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": ["https://6yqx5sih.mirror.aliyuncs.com"]
}
EOF
sudo systemctl daemon-reload
sudo systemctl restart docker
1
2
3
4
5
6
7
8

由于本文针对Docker部署运行项目的，需要点Docker的基础，一些常用的Docker命令就不再赘述了，可以到网上查看一些资料。

Dockerfile常用指令

介绍下Dockerfile的常用指令

Docker部署运行项目

现在可以编写Dockerfile文件构建出镜像，然后通过镜像创建容器启动。

还以上篇文章的三个jar包为例(一个消费者，两个生产者)，为它们创建Dockerfile文件。

1. 消费者Dockerfile

FROM java:8
COPY consumer-1.0-SNAPSHOT.jar consumer-1.0-SNAPSHOT.jar # 复制jar包
EXPOSE 9001
ENTRYPOINT ["java","-jar","consumer-1.0-SNAPSHOT.jar"] # 启动jar包
1
2
3
4

TIPS:文件名称最好命名为Dockerfile，构建镜像的命令可以省事儿，且jar包需要在构建的上下文内。

2. 生产者1

FROM java:8
COPY provider-8001-1.0-SNAPSHOT.jar provider-8001-1.0-SNAPSHOT.jar # 复制jar包
EXPOSE 8001
ENTRYPOINT ["java","-jar","provider-8001-1.0-SNAPSHOT.jar"] # 启动jar包
1
2
3
4

3. 生产者2

FROM java:8
COPY provider-8002-1.0-SNAPSHOT.jar provider-8002-1.0-SNAPSHOT.jar # 复制jar包
EXPOSE 8002
ENTRYPOINT ["java","-jar","provider-8002-1.0-SNAPSHOT.jar"] # 启动jar包
1
2
3
4

分别到三个Dockerfile所在目录下，执行构建命令

docker build -t consumer:0.0.1-SNAPSHOT .
docker build -t provider1:0.0.1-SNAPSHOT .
docker build -t provider2:0.0.1-SNAPSHOT .
1
2
3

后面有个.代表Dockerfile文件的相对位置，表示当前路径

• 运行完毕后，docker images查看镜像

3个镜像就已经构建完毕了，分别创建它们的启动容器启动即可。

docker run --name consumer -d -p 9001:9001 consumer:0.0.1-SNAPSHOT
docker run --name provider1 -d -p 8001:8001 provider1:0.0.1-SNAPSHOT
docker run --name provider2 -d -p 8002:8002 provider2:0.0.1-SNAPSHOT
1
2
3

docker ps查看下运行的容器

Jenkins+Gitlab+Docker普通部署运行

上面介绍的是简单的Docker部署运行，那么完整的一整套流程采用Jenkins+Gitlab+Docker的方式部署运行。

• 在消费者和提供者项目的pom.xml文件中增加插件，docker-maven-plugin

<plugin>
    <groupId>com.spotifygroupId>
    <artifactId>docker-maven-pluginartifactId>
    <version>0.4.13version>
    <configuration>
        <imageName>${artifactId}:${version}imageName>
        <baseImage>java:8baseImage>
        <entryPoint>["java","-jar","${project.build.finalName}.jar"]entryPoint>
        <resources>
            <resource>
                <targetPath>/targetPath>
                <directory>${project.build.directory}directory>
                <include>${project.build.finalName}.jarinclude>
            resource>
        resources>
    configuration>
plugin>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

• 定位到服务器Maven安装目录下，修改conf/settings.xml文件，在pluginGroups标签下新增docker插件的配置

<pluginGroup>com.spotifypluginGroup>
1

若无此配置，打包将会报错：No plugin found for prefix ‘docker’ in the current project and in the plugin groups.

• 到Jenkins项目主界面，点击配置，修改之前的配置，定位到构建(Build)一栏

  • 第一步先执行脚本，因为镜像和容器名称都不能重复，所以这段脚本会停止正在运行的容器删除以前的镜像和容器

  array=("consumer" "provider-8001" "provider-8002")
  for item in ${array[@]};
  do
    instance=$(docker ps -a | grep $item | head -1);#查找这个容器
    image=$(docker images | grep $item | awk '{print $1}' | head -1);#查找镜像
    if [ "$instance"x != ""x ] ; then
      docker stop $item # 停止容器
      docker rm $item # 删除容器
    fi
    if [ "$image"x != ""x ] ; then
          docker rmi $item:1.0-SNAPSHOT # 删除镜像
    fi
  done
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13

  • 第二步，执行打包构建镜像

  clean package docker:build
  1

  • 第三步，创建并执行容器

  docker run --name consumer -d -p 9001:9001 consumer:1.0-SNAPSHOT
  docker run --name provider-8001 -d -p 8001:8001 provider-8001:1.0-SNAPSHOT
  docker run --name provider-8002 -d -p 8002:8002 provider-8002:1.0-SNAPSHOT
  1
  2
  3

完事儿后，提交下代码到gitlab，然后webhook或手动触发一下构建即可。执行完毕后，看到images和容器都已经创建好，并且容器已经启动。

Jenkins+Gitlab+Dockerfile部署运行

当遇到比较复杂的场景时，我们可以使用Dockerfile的方式。具体如下：

• 首先修改项目的pom.xml文件

<plugin>
    <groupId>com.spotifygroupId>
    <artifactId>docker-maven-pluginartifactId>
    <version>0.4.13version>
    <configuration>

        <imageName>${artifactId}:${version}imageName>
        <dockerDirectory>${project.basedir}/src/main/dockerdockerDirectory>
        <resources>
            <resource>
                <targetPath>/targetPath>
                <directory>${project.build.directory}directory>
                <include>${project.build.finalName}.jarinclude>
            resource>
        resources>
    configuration>
plugin>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

• 那么就需要在项目(各个子工程)的根目录/src/main下，创建一个docker的目录，再创建一个Dockerfile文件

消费者Dockerfile

FROM java:8
COPY consumer-1.0-SNAPSHOT.jar consumer-1.0-SNAPSHOT.jar # 复制jar包
EXPOSE 9001
ENTRYPOINT ["java","-jar","consumer-1.0-SNAPSHOT.jar"] # 启动jar包
1
2
3
4

其他两个生产者

FROM java:8
COPY provider-8001-1.0-SNAPSHOT.jar provider-8001-1.0-SNAPSHOT.jar # 复制jar包
EXPOSE 8001
ENTRYPOINT ["java","-jar","provider-8001-1.0-SNAPSHOT.jar"] # 启动jar包
1
2
3
4

FROM java:8
COPY provider-8002-1.0-SNAPSHOT.jar provider-8002-1.0-SNAPSHOT.jar # 复制jar包
EXPOSE 8002
ENTRYPOINT ["java","-jar","provider-8002-1.0-SNAPSHOT.jar"] # 启动jar包
1
2
3
4

完事儿后，在Jenkins重新构建项目即可。

看到这里，可能会有读者比较迷茫，Dockerfile中的COPY指令执行时，打包后的jar包是否和Dockerfile文件在同一上下文中呢？

其实，在项目的pom.xml中引入的docker打包插件已经考虑到这种情况了，它会将你的打包后的jar包和Dockerfile文件拷贝到target/docker的目录下，这时你就不需要担心构建时不在同一目录的问题了。