Docker入门到实践（十）IDEA集成Docker构建容器镜像、部署项目

Docker 入门到实践系列文章列表：

Docker 入门到实践 (一) docker 简介与装置
Docker 入门到实践 (二) docker 常用指令解说
Docker 入门到实践 (三) Dockerfile 解析与镜像制造
Docker 入门到实践 (四) docker 容器数据卷与数据卷容器
Docker 入门到实践 (五) docker 数据的备份、恢复与搬迁
Docker 入门到实践 (六) docker 网络形式详解以及容器间的网络通信
Docker 入门到实践 (七) docker 常用软件的装置
Docker 入门到实践 (八) 本地镜像推送到阿里云 和 下载镜像到本地
Docker 入门到实践 (九) docker 可视化界面 portainer 的装置与运用
Docker 入门到实践 (十) IDEA 集成 Docker 构建容器镜像，布置项目
Docker 入门到实践 (十一) docker 私有库房的建立与装备
Docker 入门到实践 (十二) docker compose 简介与装置
Docker 入门到实践 (十三) docker compose 装备文件与常用指令解说
Docker 入门到实践 (十四) docker 企业级容器镜像库房 HarBor 的建立与装备

一、前言

  在上一篇文章中已经介绍了 docker 可视化界面 portainer 的装置与运用, 下面正式进入到 IDEA 集成 Docker 构建容器镜像，布置项目的解说。

二、敞开 docker 的 tcp 长途拜访

因为运用 IDEA 来构建容器镜像，布置项目关于 Linux 服务器上的 docker 宿主机来说是一种长途操作，而长途操作 docker 默认是封闭的，就需求咱们敞开长途拜访

//1、编辑docker.service
vim /usr/lib/systemd/system/docker.service
//2、修正ExecStart特点，在后边增加-H tcp://0.0.0.0:2375 -H unix:///var/run/docker.sock
ExecStart=/usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock -H tcp://0.0.0.0:2375 -H unix:///var/run/docker.sock
//3、刷新装备，重启服务
systemctl daemon-reload
systemctl restart docker

翻开浏览器，在地址栏中输入http://Linux的ip地址:2375/version，出现如下图片中的相关信息，则表明成功敞开 docker 的 tcp 长途拜访

三、经过 docker 的 maven 插件构建镜像

方法一：不运用 Dockerfile 来构建镜像

1、在 pom.xml 中增加如下装备，更多相关装备信息请查看：装备详解

<build>
    <!-- 打包后的文件称号 -->
    <finalName>app</finalName>
    <plugins>
        <!-- Maven 插件 -->
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <!-- 项目根据maven pom多模块的开发的，需求设置goal-repackage特点为true，不然打包后依靠文件没有一同打包，导致镜像内没有能够运转的程序文件 -->
            <executions>
               <execution>
                   <goals>
                       <goal>repackage</goal>
                   </goals>
               </execution>
            </executions>
            <configuration>
              <includeSystemScope>true</includeSystemScope>
            </configuration>
        </plugin>
        <!--运用docker-maven-plugin插件，官网：https://github.com/spotify/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>
                <!--指定标签，可增加多个imageTag，为同一个镜像指定多个标签-->
                <imageTags>
                    <imageTag>latest</imageTag>
                </imageTags>
                <!-- 用于指定根底镜像，类似于Dockerfile中的FROM指令 -->
                <baseImage>java:8u111</baseImage>
                <!--
                   类似于Dockerfile的ENTRYPOINT指令,
                   因为tomcat的session id的生成首要经过java.security.SecureRandom生成随机数来完成，导致发动进程很慢
                   经过-Djava.security.egd=file:/dev/./urandom参数能够加速随机数发生进程
                -->
                <entryPoint>["java", "-Djava.security.egd=file:/dev/./urandom", "-jar", "/${project.build.finalName}.jar"]</entryPoint>
                <!-- 这里是仿制 jar 包到 docker 容器指定目录装备 -->
                <resources>
                    <resource>
                        <targetPath>/</targetPath>
                        <!--指定需求仿制项目jar包的地点途径，${project.build.directory}表明target目录 -->
                        <directory>${project.build.directory}</directory>
                        <!-- 用于指定需求仿制的文件。${project.build.finalName}.jar指的是打包后的jar包文件　-->
                        <include>${project.build.finalName}.jar</include>
                    </resource>
                </resources>
                <!--指定长途 docker api地址-->
                <dockerHost>http://192.168.198.124:2375</dockerHost>
                <!-- 如需重复构建相同标签称号的镜像，可将forceTags设为true，这样就会掩盖构建相同标签的镜像。 -->
                <forceTags>true</forceTags>
            </configuration>
        </plugin>
    </plugins>
</build>

以上装备会主动生成如下的 Dockerfile 文件

# Base images 根底镜像
FROM java:8u111
#ADD  app.jar文件将复制到容器根目录下，复制曩昔会主动解压
ADD app.jar /
#ENTRYPOINT 运用发动指令 参数设定
#因为tomcat的session id的生成首要经过java.security.SecureRandom生成随机数来完成，导致发动进程很慢
#经过-Djava.security.egd=file:/dev/./urandom参数能够加速随机数发生进程
ENTRYPOINT ["java", "-Djava.security.egd=file:/dev/./urandom", "-jar", "/app.jar"]

2、在 windows 的指令提示符下 或许 IDEA 集成的 Terminal 窗口，进入到工程地点的目录，输入以下指令，进行打包、构建和上传镜像

/**
 * mvn clean package：表明打包项目
 * docker:build：表明构建docker镜像
 **/
mvn clean package docker:build
/**
 * 假如在pom.xml中增加了如下装备，则在履行mvn package，就会主动履行mvn docker:build
 * 即能够省掉docker:build，指令为 mvn clean package
 **/
<executions>
    <execution>
	<id>build-image</id>
	<phase>package</phase>
	<goals>
	    <goal>build</goal>
	</goals>
    </execution>
</executions>
/**
 * 假如需求把镜像上传到私有库房或许阿里云库房中，则需求进行以下两步操作
 **/
//1、修正<imageName>标签，上传到私有库房，则装备如下
<imageName>Linux的ip地址:5000/${project.artifactId}</imageName>
//上传到阿里云库房，则装备如下
<imageName>registry.cn-地域称号.aliyuncs.com/你的命名空间称号/${project.artifactId}</imageName>
//2、在指令行后边增加 -DpushImage：表明推送镜像到库房中
mvn clean package docker:build -DpushImage
或许
mvn clean package -DpushImage (需求在pom.xml中装备<executions>的相关信息)

3、运转镜像，发生容器实例。留意： 第二个 7001 端口 (即：容器端口)，是你项目的 application.yml / application.properties 装备文件中 server.port 指定的端口

4、拜访项目

方法二：经过 Dockerfile 完成细腻化的镜像构建

因为在很多场景下，咱们希望运用 Dockerfile 进行更精确、有可读性地构建容器镜像，接下来就让咱们来了解一下，如何经过 Dockerfile 进行镜像的构建

1、首先，在项目的 src/main 途径下，创立一个 docker 目录，并在 docker 目录下新建一个 Dockerfile 文件，其内容如下所示：

# Base images 根底镜像
FROM java:8u111
#MAINTAINER 维护者信息
MAINTAINER wubin<1035644768@qq.com>
#VOLUME：挂载目录
VOLUME /temp
#ADD  将app.jar文件将复制到容器中，默认复制到根途径下
#也能够直接写成ADD app.jar /app.jar 或许 ADD app.jar /
ADD app.jar app.jar
#修正app.jar这个文件的拜访时刻和修正时刻为当时时刻，而不会修正文件的内容。
RUN bash -c "touch /app.jar"
#EXPOSE 容器露出端口
EXPOSE 7001
#ENTRYPOINT 运用发动指令 参数设定
#因为tomcat的session id的生成首要经过java.security.SecureRandom生成随机数来完成，导致发动进程很慢
#经过-Djava.security.egd=file:/dev/./urandom参数能够加速随机数发生进程
ENTRYPOINT ["java", "-Djava.security.egd=file:/dev/./urandom", "-jar", "/app.jar"]

2、修正 pom.xml，不再指定<baseImage>和<entrypoint>标签，而是运用<dockerDirectory>指定 Dockerfile 地点的途径

<build>
  <!-- 打包后的文件称号 -->
  <finalName>app</finalName>
  <plugins>
      <!-- Maven 插件 -->
      <plugin>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-maven-plugin</artifactId>
          <!-- 项目根据maven pom多模块的开发的，需求设置goal-repackage特点为true，不然打包后文件依靠文件没有一同打包，然后镜像内没有能够运转的程序文件,显现错误no main manifest attribute, in /app.jar -->
          <executions>
              <execution>
                  <goals>
                      <goal>repackage</goal>
                  </goals>
              </execution>
          </executions>
          <configuration>
              <includeSystemScope>true</includeSystemScope>
          </configuration>
      </plugin>
      <!--运用docker-maven-plugin插件，官网：https://github.com/spotify/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>
              <!--指定标签，可增加多个imageTag，为同一个镜像指定多个标签-->
              <imageTags>
                  <imageTag>latest</imageTag>
              </imageTags>
              <!-- 指定 Dockerfile 途径-->
              <dockerDirectory>${project.basedir}/src/main/docker</dockerDirectory>
              <!-- 这里是仿制 jar 包到 docker 容器指定目录装备 -->
              <resources>
                  <resource>
                      <targetPath>/</targetPath>
                      <!--指定需求仿制项目jar包的地点途径，${project.build.directory}表明target目录 -->
                      <directory>${project.build.directory}</directory>
                      <!-- 用于指定需求仿制的文件。${project.build.finalName}.jar指的是打包后的jar包文件　-->
                      <include>${project.build.finalName}.jar</include>
                  </resource>
              </resources>
              <!--指定长途 docker api地址-->
              <dockerHost>http://192.168.198.124:2375</dockerHost>
              <!-- 如需重复构建相同标签称号的镜像，可将forceTags设为true，这样就会掩盖构建相同标签的镜像。 -->
              <forceTags>true</forceTags>
          </configuration>
      </plugin>
  </plugins>
</build>

3、履行相关指令，与方法一：不运用 Dockerfile 来构建镜像的进程 2 一样，这里不再重复

四、经过 IDEA 的 Docker 插件构建镜像

1、装置 Docker 插件

1.1、在顶部工具栏中找到 File → Settings

1.2、找到 Plugins，点击 “Browse repositories” 按钮

1.3、在搜索框输入 Docker，选择 Docker 插件，点击 “Install” 按钮进行装置，然后点击 “Close” 按钮

3.2、能够看到 Docker 插件已经被咱们装置上了，然后点击 “Apply” 按钮，再点击 “OK” 按钮，最后重启 IDEA 即可收效

2、装备 Docker 服务

2.1、在顶部工具栏中找到 File → Settings，进入到 Settings 设置页面中，找到 Build，Execution，Deployment → Docker，点击 “+”，增加一个 docker 衔接

2.2、在 Engine API URL 中输入你的 docker 服务地址，格局为：tcp://Linux(即: docker 宿主机) 的 ip 地址: 2375，装备好后，idea 会主动检测，然后在左下方输出 “connection successful”，然后点击 “Apply” 按钮，再点击 “OK” 按钮

2.3、选择 IDEA 的 Docker 窗口，点击 “绿色运转按钮”，衔接 Linux 服务器上的 docker，衔接成功之后，会显现 Containers 和 Images，即：docker 中已有的容器和镜像

3、经过 Docker 插件构建镜像

1、首先，在项目的 src/main 途径下，创立一个 docker 目录，并在 docker 目录下新建一个 Dockerfile 文件，其内容如下所示：

# Base images 根底镜像
FROM java:8u111
#MAINTAINER 维护者信息
MAINTAINER wubin<1035644768@qq.com>
#VOLUME：挂载目录
VOLUME /temp
#ADD  将microservicecloud-eureka-7001-1.0-SNAPSHOT.jar文件将复制到容器中，默认复制到根途径下
#留意：microservicecloud-eureka-7001-1.0-SNAPSHOT.jar的称号前的microservicecloud-eureka-7001对应<artifactId>标签中的内容，1.0-SNAPSHOT对应<version>标签中的内容
ADD microservicecloud-eureka-7001-1.0-SNAPSHOT.jar app.jar
RUN bash -c "touch /app.jar"
#EXPOSE 容器露出端口
EXPOSE 7001
#ENTRYPOINT 运用发动指令 参数设定
#因为tomcat的session id的生成首要经过java.security.SecureRandom生成随机数来完成，导致发动进程很慢
#经过-Djava.security.egd=file:/dev/./urandom参数能够加速随机数发生进程
ENTRYPOINT ["java", "-Djava.security.egd=file:/dev/./urandom", "-jar", "/app.jar"]

2、创立 Dockerfile 发动项

2.1、选择 Edit Configurations…

2.2、点击 “+”，找到 Docker，选择 Dockerfile

2.3、装备 Dockerfile 发动项的相关信息

留意： 容器端口，是你项目的 application.yml / application.properties 装备文件中 server.port 指定的端口

3、在 pom.xml 文件中增加 SpringBoot 的 maven 插件，假如不增加，运转容器时，会报错，错误信息为：no main manifest attribute, in /xxx.jar

<build>
   <plugins>
       <plugin>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-maven-plugin</artifactId>
           <!-- 项目根据maven pom多模块的开发的，需求设置goal-repackage特点为true，不然打包后文件依靠文件没有一同打包，然后镜像内没有能够运转的程序文件 -->
           <executions>
               <execution>
                   <goals>
                       <goal>repackage</goal>
                   </goals>
               </execution>
           </executions>
           <configuration>
               <includeSystemScope>true</includeSystemScope>
           </configuration>
       </plugin>
   </plugins>
</build>

4、履行 mvn clean install 指令，打包项目并装置到本地的 maven 库房中

5、在本地 maven 库房中找到方才装置好的 microservicecloud-eureka-7001-1.0-SNAPSHOT.jar，复制到项目的 src/main/docker 目录下，并运转 Docker 发动项，Docker 插件会主动帮咱们构建项目镜像，并发动容器实例

因为咱们在 Dockerfile 文件中装备了ADD microservicecloud-eureka-7001-1.0-SNAPSHOT.jar app.jar，而 Dockerfile 文件是放在项目的 src/main/docker 目录下，所以它会在当时目录(即：docker目录)下寻找microservicecloud-eureka-7001-1.0-SNAPSHOT.jar

6、拜访项目

改进：前面说了，咱们需求把项目的 jar 包复制到 docker 目录下，然后再运转，有什么方法能够不复制项目的 jar 包到 docker 目录下，直接运转呢？解决方案如下：

1、删除之前的 docker 目录，在项目的根目录下，新建一个 Dockerfile 文件，内容如下：

留意：需求将之前的ADD microservicecloud-eureka-7001-1.0-SNAPSHOT.jar app.jar 修正为 ADD /target/microservicecloud-eureka-7001-1.0-SNAPSHOT.jar app.jar，让它去读取 target 目录下的项目 jar 包

# Base images 根底镜像
FROM java:8u111
#MAINTAINER 维护者信息
MAINTAINER wubin<1035644768@qq.com>
#VOLUME：挂载目录
VOLUME /temp
#ADD  将microservicecloud-eureka-7001-1.0-SNAPSHOT.jar文件将复制到容器中，默认复制到根途径下
ADD /target/microservicecloud-eureka-7001-1.0-SNAPSHOT.jar app.jar
RUN bash -c "touch /app.jar"
#EXPOSE 容器露出端口
EXPOSE 7001
#ENTRYPOINT 运用发动指令 参数设定
#因为tomcat的session id的生成首要经过java.security.SecureRandom生成随机数来完成，导致发动进程很慢
#经过-Djava.security.egd=file:/dev/./urandom参数能够加速随机数发生进程
ENTRYPOINT ["java", "-Djava.security.egd=file:/dev/./urandom", "-jar", "/app.jar"]

2、修正 Docker 发动项，重新指定 Dockerfile 文件的地点途径

3、删除之前运转的项目容器实例 和 项目镜像

4、履行 mvn clean package 指令，把项目的 jar 包装置到当时项目的 target 目录下，最后运转 Docker 发动项

小提示：咱们也能够经过 IDEA 的 Docker 插件，进行如下操作：

1、运转镜像，创立容器实例

2、拉取镜像

本文由 简悦 SimpRead 转码， 原文地址 blog.csdn.net