前置一：利用Dockerfile 将一个war包生成镜像的Dockerfile

  • 1、docker下创建项目工程名称
1
2
3
4
5
mkdir -p /usr/local/docker/yida/ 
cd /usr/local/docker/yida 、

# 将桌面qfjy_exam.zip复制到访目录下
cp yida-sync-1.0-SNAPSHOT.zip  /usr/local/docker/yida/
  • 2、创建镜像文件Dockerfile
1
2
3
4
5
6
7
FROM tomcat 
WORKDIR /usr/local/tomcat/webapps/ROOT # 指定工作目录
RUN rm -rf * # 删除指定目录所有内容
COPY yida-sync-1.0-SNAPSHOT.zip  /usr/local/tomcat/webapps/ROOT # 复制到ROOT下
RUN unzip yida-sync-1.0-SNAPSHOT.zip # 解压文件
RUN rm -rf yida-sync-1.0-SNAPSHOT.zip # 移除多余的压缩包
WORKDIR /usr/local/tomcat # 指定工作目录
  • 3、构建镜像
1
docker build -t yida-sync:latest .
  • 4、进入镜像内查看
1
docker run -it yida-sync bash

前置二：Docker部署springboot项目

准备springboot jar项目

Dockerfile

1
2
3
4
5
FROM java:8 
VOLUME /tmp 
ADD  yida-sync-1.0-SNAPSHOT.jar app.jar  
EXPOSE 8080 
ENTRYPOINT ["java","-Djava.security.egd=file:/dev/./urandom","-jar","/app.jar"]

FROM：表示基础镜像，即运行环境

VOLUME /tmp创建/tmp目录并持久化到Docker数据文件夹，因为Spring Boot使用的内嵌Tomcat容器默认使 用/tmp作为工作目录

ADD：拷贝文件并且重命名(ADD exam-0.0.1-SNAPSHOT.jar exam.jar 将应用jar包复制到/exam.jar)

EXPOSE：并不是真正的发布端口，这个只是容器部署人员与建立image的人员之间的交流，即建立image的人 员告诉容器布署人员容器应该映射哪个端口给外界

ENTRYPOINT：容器启动时运行的命令，相当于我们在命令行中输入java -jar xxxx.jar，为了缩短 Tomcat 的启 动时间，添加java.security.egd的系统属性指向/dev/urandom作为 ENTRYPOINT

构建容器 

1
docker build -t yida-sync:latest .

运行容器 

1
docker run --rm -d --name 容器名称 -p 8080:8080 镜像名称

其中-d表示后台运行容器，这也就自然地解决的Spring Boot不支持后台运行应用程序的问题。

-p 8080:8080表示将容器内部的8080端口映射到宿主机器的8080端口，这样就可以通过宿主机器直接访问应 用。

–name 给容器取一个容易记住的名字方便日后管理。

查看运行日志 

1
docker logs -f --tail=100 容器名称

Maven 插件之 docker-maven-plugin 的使用

在我们持续集成过程中，项目工程一般使用 Maven 编译打包，然后生成镜像，通过镜像上线，能够大大提供上线效率，同时能够快速动态扩容，快速回滚，着实很方便。docker-maven-plugin 插件就是为了帮助我们在Maven工程中，通过简单的配置，自动生成镜像并推送到仓库中。

前置：配置DOCKER_HOST

需要配置DOCKER做镜像的地址，docker-maven-plugin 插件默认连接本地 Docker 地址为：localhost:2375，我们也可以通过i设置环境变量修改DOCKER地址，本地没DOCKER需要配置服务器上DOCKER地址，服务上Docker需要开启远程访问 

1
DOCKER_HOST=tcp://<host>:2375
  • 注意：如果没有设置 DOCKER_HOST 环境变量，可以命令行显示指定 DOCKER_HOST 来执行，如我本机指定 DOCKER_HOST：DOCKER_HOST=unix:///var/run/docker.sock mvn clean install docker:build。
  • 也可以直接在pom文件中指定<dockerHost>http://120.48.20.139:2375</dockerHost>
Docker开启远程访问

低版本Docker

1
2
3
4
5
6
7
8
#修改该Docker服务文件 
vi /lib/systemd/system/docker.service 

#修改ExecStart这行  将文件内的 ExecStart注释。 新增如下行。 集在ExecStart行最后增加，-H tcp://0.0.0.0:2375  开放远程主机访问权限。 

#ExecStart=/usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock
ExecStart=/usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock -H tcp://0.0.0.0:2375

高版本Docker

[root@microservice ~]# vim /usr/lib/systemd/system/docker.service
在ExecStart=/usr/bin/dockerd-current 后面加上-H tcp://0.0.0.0:2375 -H unix://var/run/docker.sock \

1
2
3
4
5
6
7
8
9
10
11
12
重新加载配置文件和启动：
systemctl daemon-reload
systemctl start docker

#查看端口是否开启 
netstat -nlpt     

#如果找不到netstat命令，可进行安装。
yum install net-tools 

#直接curl看是否生效 
curl http://127.0.0.1:2375/info

20200603081807

1. 示例构建镜像

构建镜像可以使用一下两种方式：

  • 第一种是将构建信息指定到 POM 中
  • 第二种是使用已存在的 Dockerfile 构建

第一种方式，支持将 FROM, ENTRYPOINT, CMD, MAINTAINER 以及 ADD 信息配置在 POM 中，不需要使用 Dockerfile 配置。但是如果使用 VOLUME 或其他 Dockerfile 中的命令的时候，需要使用第二种方式，创建一个 Dockerfile，并在 POM 中配置 dockerDirectory 来指定路径即可。

1.1 指定构建信息到 POM 中构建
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
 <properties>
    <docker.image.prefix>registry.cn-beijing.aliyuncs.com/zzxxxy</docker.image.prefix>
</properties>

<plugin>
    <groupId>com.spotify</groupId>
    <artifactId>docker-maven-plugin</artifactId>
    <version>1.0.0</version>
    <executions>
         <!--绑定Docker build  命令到 Maven package阶段 -->
        
        <execution>
            <id>build-image</id>
            <phase>package</phase>
            <goals>
                <goal>build</goal>
            </goals>
        </execution>
    </executions>
    <configuration>
        <!--指定生成的镜像名 zzxx/blog -->
        <imageName>${docker.image.prefix}/${project.artifactId}:${project.version}</imageName>
        <!--指定标签-->
        <imageTags>
            <!--使用项目版本号-->
            <imageTag>${project.version}</imageTag>
            <!-- <imageTag>latest</imageTag>-->
        </imageTags>
        <!-- 基础镜像openjdk:8-->
        <baseImage>openjdk:8-jdk-alpine</baseImage>
        <!-- 制作者提供本人信息 -->
        <maintainer>zzxx zzxx@aliyun.com</maintainer>
        <!--切换到/ROOT目录 -->
        <workdir>/ROOT</workdir>
        <cmd>["java", "-version"]</cmd>
        <entryPoint>["java", "-jar", "${project.build.finalName}.jar"]</entryPoint>
        <!--指定远程 docker api地址-->
        <dockerHost>http://120.48.20.139:2375</dockerHost>
        <!-- 这里是复制 jar 包到 docker 容器指定目录配置 -->
        <resources>
            <resource>
                <targetPath>/ROOT</targetPath>
                <!--用于指定需要复制的根目录，${project.build.directory}表示target目 录-->
                <directory>${project.build.directory}</directory>
                <!--用于指定需要复制的文件。${project.build.finalName}.jar指的是打包 后的jar包文件。-->
                <include>${project.build.finalName}.jar</include>
            </resource>
        </resources>
             <!-- 以下三行是为了docker push到DockerHub使用的。 -->
        <serverId>aliyun-docker-registry</serverId>
        <pushImage>true</pushImage>
        <registryUrl>${docker.image.prefix}</registryUrl>
    </configuration>
</plugin>
1.2 使用 Dockerfile 构建
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
 <properties>
    <docker.image.prefix>registry.cn-beijing.aliyuncs.com/zzxxxy</docker.image.prefix>
</properties>
      <plugin>
                <groupId>com.spotify</groupId>
                <artifactId>docker-maven-plugin</artifactId>
                <version>1.0.0</version>
                <executions>
                    <execution>
                        <id>build-image</id>
                        <phase>package</phase>
                        <goals>
                            <goal>build</goal>
                        </goals>
                    </execution>
                </executions>
                <configuration>
                    <imageName>${docker.image.prefix}/${project.artifactId}:${project.version}</imageName>
                    <!--指定标签 imageName 中已经带标签了 这块如果和imageName中不一样则会多生成tag-->
                    <imageTags>
                        <imageTag>latest</imageTag>
                    </imageTags>

                    <dockerDirectory>${project.basedir}</dockerDirectory>
                    <!--指定远程 docker api地址-->
                    <dockerHost>http://120.48.20.139:2375</dockerHost>
                    <!-- 以下三行是为了docker push到DockerHub使用的。 -->
                    <serverId>aliyun-docker-registry</serverId>
                    <pushImage>false</pushImage>
                    <registryUrl>${docker.image.prefix}</registryUrl>
                </configuration>
            </plugin>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#基于java8
FROM openjdk:8-jdk-alpine

#创建一个目录存放jar包
RUN mkdir -p /data/config /data/logs

#复制jar包以及相关配置文件
COPY target/yida-sync-0.0.1-SNAPSHOT.jar /app.jar

#添加进入docker容器后的目录
WORKDIR /data/

#对外暴露的端口号
EXPOSE 8111

#运行脚本，启动springboot项目，这里我们指定加载配置文件的位置，并且通过数据卷挂载同步到容器中
ENTRYPOINT ["java","-jar","/app.jar","> /data/logs/yida_sync.log 2>&1 &"]

2. 执行命令

mvn clean package docker:build 只执行 build 操作

mvn clean package docker:build -DpushImage 执行 build 完成后 push 镜像

mvn clean package docker:build -DpushImageTag 执行 build 并 push 指定 tag 的镜像
注意：这里必须指定至少一个 imageTag，它可以配置到 POM 中，也可以在命令行指定。命令行指定如下：mvn clean package docker:build -DpushImageTags -DdockerImageTags=imageTag_1 -DdockerImageTags=imageTag_2，POM 文件中指定配置如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<build>
  <plugins>
    ...
    <plugin>
      <configuration>
        ...
        <imageTags>
           <imageTag>imageTag_1</imageTag>
           <imageTag>imageTag_2</imageTag>
        </imageTags>
      </configuration>
    </plugin>
    ...
  </plugins>
</build>

3. 绑定Docker 命令到 Maven 各个阶段

我们可以绑定 Docker 命令到 Maven 各个阶段，我们可以把 Docker 分为 build、tag、push，然后分别绑定 Maven 的 package、deploy 阶段，此时，我们只需要执行mvn deploy就可以完成整个 build、tag、push操作了，当我们执行mvn build就只完成 build、tag 操作。除此此外，当我们想跳过某些步骤或者只执行某个步骤时，不需要修改 POM 文件，只需要指定跳过 docker 某个步骤即可。比如当我们工程已经配置好了自动化模板了，但是这次我们只需要打镜像到本地自测，不想执行 push 阶段，那么此时执行要指定参数-DskipDockerPush就可跳过 push 操作了。

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
 <properties>
    <docker.image.prefix>registry.cn-beijing.aliyuncs.com/zzxxxy</docker.image.prefix>
</properties>
<plugin>
    <groupId>com.spotify</groupId>
    <artifactId>docker-maven-plugin</artifactId>
    <version>1.0.0</version>
    <executions>
        <!--当执行mvn package时，执行: mvn clean package docker:build -->
        <execution>
            <id>build-image</id>
            <phase>package</phase>
            <goals>
                <goal>build</goal>
            </goals>
        </execution>
         <!--因为目前我这个imageName直接就是标准的远程仓库Name不需要tag -->
        <!--<execution>
            <id>tag-image</id>
            <phase>package</phase>
            <goals>
                <goal>tag</goal>
            </goals>
            <configuration>
                <image>mavendemo:latest</image>
                <newName>${docker.image.prefix}/${project.artifactId}:${project.version}</newName>
            </configuration>
        </execution>-->
         <!--当执行mvn deploy，执行build、tag、push 操作。 -->
        <execution>
            <id>push-image</id>
            <phase>deploy</phase>
            <goals>
                <goal>push</goal>
            </goals>
            <configuration>
                <imageName>${docker.image.prefix}/${project.artifactId}:${project.version}</imageName>
            </configuration>
        </execution>
    </executions>
    <configuration>
        <imageName>${docker.image.prefix}/${project.artifactId}</imageName>
        <!--指定标签-->
        <imageTags>
            <imageTag>latest</imageTag>
        </imageTags>
        <dockerDirectory>${project.basedir}</dockerDirectory>
        <!--指定远程 docker api地址-->
        <dockerHost>http://120.48.20.139:2375</dockerHost>
        <serverId>aliyun-docker-registry</serverId>
        <pushImage>false</pushImage>
        <registryUrl>${docker.image.prefix}</registryUrl>
    </configuration>
</plugin>

以上示例，当我们执行mvn package时，执行 build、tag 操作，当执行mvn deploy时，执行build、tag、push 操作。如果我们想跳过 docker 某个过程时，只需要：

  • -DskipDockerBuild 跳过 build 镜像
  • -DskipDockerTag 跳过 tag 镜像
  • -DskipDockerPush 跳过 push 镜像
  • -DskipDocker 跳过整个阶段

例如：我们想执行 package 时，跳过 tag 过程，那么就需要mvn package -DskipDockerTag。

4. 使用私有 Docker 仓库地址

实际工作环境中，我们需要 push 镜像到我们私有 Docker 仓库中，使用d ocker-maven-plugin 插件我们也是很容易实现，有几种方式实现：

4.1 修改 POM 文件 imageName 操作
1
2
3
4
5
6
...
<configuration>
    <imageName>registry.example.com/wanyang3/mavendemo:v1.0.0</imageName>
    ...
</configuration>
...
4.2 修改 POM 文件中 newName 操作
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
...
<configuration>
    <imageName>mavendemo</imageName>
    ...
</configuration>
<execution>
     <!--绑定Docker tag  命令到 Maven package阶段 -->
    <id>tag-image</id>
    <phase>package</phase>
    <goals>
        <goal>tag</goal>
    </goals>
    <configuration>
        <image>mavendemo</image>
        <newName>registry.example.com/wanyang3/mavendemo:v1.0.0</newName>
    </configuration>
</execution>
...

5. 安全认证配置

当我们 push 镜像到 Docker 仓库中时，不管是共有还是私有，经常会需要安全认证，登录完成之后才可以进行操作。当然，我们可以通过命令行 docker login -u user_name -p password docker_registry_host 登录，但是对于自动化流程来说，就不是很方便了。使用 docker-maven-plugin 插件我们可以很容易实现安全认证。

首先在 Maven 的配置文件 setting.xml 中增加相关 server 配置，主要配置 Docker registry用户认证信息。

1
2
3
4
5
6
7
8
9
10
<servers>
  <server>
    <id>aliyun-docker-registry</id>
    <username>zzxx</username>
    <password>12345678</password>
    <configuration>
      <email>zzxx@mail.com</email>
    </configuration>
  </server>
</servers>

然后只需要在 pom.xml 中使用 server id 即可。

1
2
3
4
5
6
7
8
9
10
11
12
<plugin>
  <plugin>
    <groupId>com.spotify</groupId>
    <artifactId>docker-maven-plugin</artifactId>
    <version>1.0.0</version>
    <configuration>
      <serverId>aliyun-docker-registry</serverId>
       <pushImage>true</pushImage>
      <registryUrl>${docker.image.prefix}</registryUrl>
    </configuration>
  </plugin>
</plugins>

6. 其他参数

docker-maven-plugin 插件还提供了很多很实用的配置，稍微列举几个参数吧。

参数 说明 默认值
<forceTags>true</forceTags> build 时强制覆盖 tag，配合 imageTags 使用 false
<noCache>true</noCache> build 时，指定 –no-cache 不使用缓存 false
<pullOnBuild>true</pullOnBuild> build 时，指定 –pull=true 每次都重新拉取基础镜像 false
<pushImage>true</pushImage> build 完成后 push 镜像 false
<pushImageTag>true</pushImageTag> build 完成后，push 指定 tag 的镜像，配合 imageTags 使用 false
<retryPushCount>5</retryPushCount> push 镜像失败，重试次数 5
<retryPushTimeout>10</retryPushTimeout> push 镜像失败，重试时间 10s
<rm>true</rm> build 时，指定 –rm=true 即 build 完成后删除中间容器 false
<useGitCommitId>true</useGitCommitId> build 时，使用最近的 git commit id 前7位作为tag，例如：image:b50b604，前提是不配置 newName false

Maven 插件之 dockerfile-maven-plugin 的使用

  • 这个和 docker-maven-plugin一样必须需要配置DOCKER_HOST，默认连接本地 Docker 地址为：localhost:2375，如果docker是在远程则需要配置环境变量DOCKER_HOST=tcp://http://xxx.xxx.xxx.xxx:2375 ，注意此处不能像 docker-maven-plugin 在pom文件中指定<dockerHost>http://120.48.20.139:2375</dockerHost> 因为没这个参数
1
DOCKER_HOST=tcp://<host>:2375
Docker开启远程访问

低版本Docker

1
2
3
4
5
6
7
8
#修改该Docker服务文件 
vi /lib/systemd/system/docker.service 

#修改ExecStart这行  将文件内的 ExecStart注释。 新增如下行。 集在ExecStart行最后增加，-H tcp://0.0.0.0:2375  开放远程主机访问权限。 

#ExecStart=/usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock
ExecStart=/usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock -H tcp://0.0.0.0:2375

高版本Docker

[root@microservice ~]# vim /usr/lib/systemd/system/docker.service
在ExecStart=/usr/bin/dockerd-current 后面加上-H tcp://0.0.0.0:2375 -H unix://var/run/docker.sock \

1. 示例构建镜像

引入dockerfile-maven依赖
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
<properties>
    <docker.image.prefix>registry.cn-beijing.aliyuncs.com/zzxxxy</docker.image.prefix>
</properties>

<!--   dockerfile-maven-plugin      -->
<plugin>
    <groupId>com.spotify</groupId>
    <artifactId>dockerfile-maven-plugin</artifactId>
    <version>1.3.6</version>
    <executions>
        <!--绑定Docker 命令到 Maven 各个阶段 默认配置build和tag目标绑定到package阶段，push目标绑定到deploy阶段,这里不涉及tag和push目标。 -->
        <execution>
            <id>default</id>
            <goals>
                <goal>build</goal>
            </goals>
        </execution>
    </executions>
    <configuration>
        <repository>${docker.image.prefix}/${project.artifactId}</repository>
        <tag>${project.version}</tag>
        <buildArgs>
            <JAR_FILE>${project.build.finalName}.jar</JAR_FILE>
        </buildArgs>
    </configuration>
</plugin>

注解：

  • execution指定了该插件build目标使用默认绑定。默认的，build和tag目标绑定到package阶段，push目标绑定到deploy阶段,这里不涉及tag和push目标。
  • repository是生成的镜像的repository信息
  • tag元素指定镜像的tag，这里使用Maven模块的版本号；
  • buildArgs元素指定了传递给Dockerfile的参数，比如上面Dockerfile中的JAR_FILE.
  • ${project.build.finalName}.jar是jar包路径，这里使用了最终生成的jar包的文件名

执行构建命令：mvn -DskipTests=true clean package我们可以看到插件的执行过程也就是build镜像的过程

准备DockerFile
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#基于java8
FROM openjdk:8-jdk-alpine

#创建一个目录存放jar包
RUN mkdir -p /data/config /data/logs

#复制jar包以及相关配置文件
ARG JAR_FILE
ADD target/${JAR_FILE} /app.jar

#添加进入docker容器后的目录
WORKDIR /data/

#对外暴露的端口号
EXPOSE 8111

#运行脚本，启动springboot项目，这里我们指定加载配置文件的位置，并且通过数据卷挂载同步到容器中
ENTRYPOINT ["java","-jar","/app.jar","> /data/logs/yida_sync.log 2>&1 &"]

2. 执行命令

跳过插件目标：

如果要临时跳过所有的Dockerfile相关的目标，执行如下Maven命令：

1
mvn clean install -Ddockerfile.skip

如果只是想跳过某一个goal，执行如下Maven命令：

1
2
3
4
5
mvn clean package -Ddockerfile.build.skip

mvn clean package -Ddockerfile.tag.skip

mvn clean deploy -Ddockerfile.push.skip

3. 绑定Docker 命令到 Maven 各个阶段

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
<plugin>
    <groupId>com.spotify</groupId>
    <artifactId>dockerfile-maven-plugin</artifactId>
    <version>1.3.6</version>
    <executions>
        <execution>
            <id>dockerfile-build</id>
            <phase>package</phase>
            <goals>
                <goal>build</goal>
                <goal>push</goal>
            </goals>
        </execution>
    </executions>
    <configuration>
        <repository>${docker.image.prefix}/${project.artifactId}</repository>
        <tag>${project.version}</tag>
        <useMavenSettingsForAuth>true</useMavenSettingsForAuth>
        <buildArgs>
            <JAR_FILE>${project.build.finalName}.jar</JAR_FILE>
        </buildArgs>
    </configuration>
</plugin>

可用于此插件的Goals ：

Goal Description Default Phase
dockerfile:build 从Dockerfile构建Docker镜像。 package
dockerfile:tag Tag Docker镜像。 package
dockerfile:push 将Docker镜像推送到repository。 deploy
  • 跳过Docker Goals 绑定到Maven phase

你可以将选项传递给maven以禁用 docker goals。

Maven Option What Does that thing Do?
dockerfile.skip Disables the entire dockerfile plugin; all goals become no-ops.
dockerfile.build.skip Disables the build goal; it becomes a no-op.
dockerfile.tag.skip Disables the tag goal; it becomes a no-op.
dockerfile.push.skip Disables the push goal; it becomes a no-op.

例如，跳过整个dockerfile插件：

1
mvn clean package -Ddockerfile.skip

4. 使用私有 Docker 仓库地址以及安全认证配置

使用maven settings.xml进行身份验证

从版本1.3.6开始，你可以使用maven的 settings.xml文件进行身份验证，而不是使用docker配置。 只需添加类似于以下配置：

1
2
3
4
5
<configuration>
  <repository>registry.cn-beijing.aliyuncs.com/zzxxxy/yida-sync</repository>
  <tag>latest</tag>
  <useMavenSettingsForAuth>true</useMavenSettingsForAuth>
</configuration>

你也可以在命令行上使用 -Ddockerfile.useMavenSettingsForAuth=true。

然后，在你的maven设置文件中，为服务器添加配置：

1
2
3
4
5
6
7
8
<servers>
  <server>
  <!--   这里的id需要和Docker 仓库地址一样  -->
    <id>registry.cn-beijing.aliyuncs.com</id>
    <username>me</username>
    <password>mypassword</password>
  </server>
</servers>
使用maven pom.xml进行身份验证

从版本1.3.XX开始，你可以使用pom本身的配置进行身份验证。 只需添加类似于以下配置（经测试，在1.4.0版本中向私有仓库push时会报错 denied: requested access to the resource is denied，所以建议使用maven settings.xml进行身份验证）：

image-20221010121841194

1
2
3
4
5
6
7
8
9
10
11
12
13
<plugin>
    <groupId>com.spotify</groupId>
    <artifactId>dockerfile-maven-plugin</artifactId>
    <version>${version}</version>
    <configuration>
        <username>repoUserName</username>
        <password>repoPassword</password>
        <repository>${docker.image.prefix}/${project.artifactId}</repository>
        <buildArgs>
            <JAR_FILE>target/${project.build.finalName}.jar</JAR_FILE>
        </buildArgs>
    </configuration>
</plugin>

或更简单，

1
2
3
4
5
6
7
8
9
10
11
<plugin>
    <groupId>com.spotify</groupId>
    <artifactId>dockerfile-maven-plugin</artifactId>
    <version>${version}</version>
    <configuration>
        <repository>${docker.image.prefix}/${project.artifactId}</repository>
        <buildArgs>
            <JAR_FILE>target/${project.build.finalName}.jar</JAR_FILE>
        </buildArgs>
    </configuration>
</plugin>

用这个命令行调用：

1
mvn clean package -U -DskipTests=true -Pdocker -Ddockerfile.username=xx_devops -Ddockerfile.password=xxxxxxx

shell自动发布

我个人不喜欢MVN和DOCKER集成，感觉直接写个shell更简单

  • 在根目录下新建run.sh
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
#!/bin/bash

mirror_name="yida"
mirror_version="latest"
aliyun_username="username"
aliyun_password="password"

# 第一个参数为 "current" 按当天名成
if [ "$1" == "current" ];then
  mirror_version=`date +%F-%H`
fi

# 运行命令生成我们的项目镜像
docker build -f Dockerfile -t yida-sync:$mirror_version .
echo "镜像构建成功"

docker login --username=${aliyun_username} -p=${aliyun_password} registry.cn-beijing.aliyuncs.com
echo "成功登录阿里云"

docker tag yida-sync:$mirror_version registry.cn-beijing.aliyuncs.com/aws-images/$mirror_name:$mirror_version

docker push registry.cn-beijing.aliyuncs.com/aws-images/$mirror_name:$mirror_version

echo "镜像上传至阿里云成功"

  • 在根目录下新建Dockerfile
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#基于java8
FROM openjdk:8-jdk-alpine

#创建一个目录存放jar包
RUN mkdir -p /data/config /data/logs

#复制jar包以及相关配置文件

COPY target/yida-sync-0.0.1-SNAPSHOT.jar /app.jar

#添加进入docker容器后的目录
WORKDIR /data/

#对外暴露的端口号
EXPOSE 8111

#运行脚本，启动springboot项目，这里我们指定加载配置文件的位置，并且通过数据卷挂载同步到容器中
ENTRYPOINT ["java","-jar","/app.jar","> /data/logs/yida_sync.log 2>&1 &"]
  • 执行运行 run.sh即可

idea集成docker实现镜像打包一键部署

如果不用IDEA一键部署需要如下：

  • 1.在IDEA工具中开发代码
  • 2.代码打成jar包
  • 3.部署到Linux服务器
  • 4.如果用Docker（编写Dockerfile文件）
  • 5.构建镜像
  • 6.运行镜像

1、Docker开启远程访问

低版本Docker

1
2
3
4
5
6
7
#修改该Docker服务文件 
vi /lib/systemd/system/docker.service 

#修改ExecStart这行  将文件内的 ExecStart注释。 新增如下行。 集在ExecStart行最后增加，-H tcp://0.0.0.0:2375  开放远程主机访问权限。 

#ExecStart=/usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock
ExecStart=/usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock -H tcp://0.0.0.0:2375

高版本Docker

1
2
[root@microservice ~]# vim /usr/lib/systemd/system/docker.service
在ExecStart=/usr/bin/dockerd-current 后面加上-H tcp://0.0.0.0:2375 -H unix://var/run/docker.sock \

1
2
3
4
5
6
7
8
9
10
11
12
重新加载配置文件和启动：
systemctl daemon-reload
systemctl start docker

#查看端口是否开启 
netstat -nlpt     

#如果找不到netstat命令，可进行安装。
yum install net-tools 

#直接curl看是否生效 
curl http://127.0.0.1:2375/info

20200603081807

2、IDEA安装Docker插件

打开Idea，从File->Settings->Plugins->Install JetBrains plugin进入插件安装界面， 在搜索框中输入docker，可以看到Docker integration，点击右边的Install按钮进行安装。 安装后重启Idea。 (2018版本之后应该全部自带Docker)

3、IDEA配置docker

配置docker，连接到远程docker服务。

从File->Settings->Build,Execution,Deployment->Docker打开配置界面

  • 可以顺便配置自己的阿里云镜像地址 当然默认也可以

  • 连接成功后，在IDEA工具中即可 操作Docker：

4、docker-maven-plugin

可以通过docker-maven-plugin 或者 dockerfile-maven-plugin 上面已经讲了

5、IDEA 操作Docker

创建容器，找到刚刚生成的镜像，点击创建容器

测试

总结： 

1
2
3
4
5
6
7
8
当我们执行 mvn package 时，执行 build、tag 操作
当执行 mvn deploy 时，执行build、tag、push 操作。
如果我们想跳过 docker 某个过程时，只需要：
    -DskipDockerBuild 跳过 build 镜像 
    -DskipDockerTag 跳过 tag 镜像 
    -DskipDockerPush 跳过 push 镜像 
    -DskipDocker 跳过整个阶段
例如：我们想执行 package 时，跳过 tag 过程，那么就需要 mvn package -DskipDockerTag