boot docker spring 远程debug springboot部署docker

springboot项目中使用docker进行远程部署

这个过程，其实就是先将项目打包为springboot的jar包，再远程连接到docker主机上将springboot的jar包构建为docker镜像。最后运行docker run [镜像名称] ，以docker容器方式运行我们的应用。 

 

方式一： idea中安装docker 集成插件，进行docker远程部署。 

安装完成后，重启idea。 在setting--》build,execution,deployment--》下找到docker ，添加/配置一个docker主机(可以是远程的docker主机)。当然，需要注意的是，远程主机上的必须有安装docker，并且开启了docker的远程访问。

新建一个简单的springboot项目 。new --》project --》spring initializr --》勾选 web ，devtool即可，项目名称填写为 docker-demo1 。

springboot启动类：

package com.tingcream.dockerdemo1;
 
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
 
import java.text.SimpleDateFormat;
import java.util.Date;
 
@SpringBootApplication
@RestController
public class DockerDemo1Application {
    @Value("${spring.application.name}")
    private  String applicationName;
    @Value("${server.port}")
    private  String port;
 
    public static void main(String[] args) {
        SpringApplication.run(DockerDemo1Application.class, args);
    }
 
    @RequestMapping("/")
    public String index(){
        String date= new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());
        System.out.println("当前时间:"+date);
        return  "hello: "+applicationName+"，端口为:"
                +port+"，当前时间为:"+date;
    }
 
}

application.yml

server:
  port: 8081

spring:
  application:
    name: docker-demo1

#日志
logging:
  level:
    root: INFO
    org.springframework.web: INFO
    org.springframework.jdbc: debug
    com.tingcream: DEBUG
  file: /log/docker-demo1.log

在项目根目录中，创建一个Dockerfile文件，内容如下：

FROM    frolvlad/alpine-oraclejre8
VOLUME /tmp

# 配置环境变量
ENV LANG="en_US.UTF-8" \
    LANGUAGE="en_US:en"  \
    LC_ALL="en_US.UTF-8"


# 复制jar包
ADD target/docker-demo1.jar   /app.jar

# 修改容器时区为北京时间
RUN sed -i 's/dl-cdn.alpinelinux.org/mirrors.ustc.edu.cn/g' /etc/apk/repositories &&\
    apk --no-cache add tzdata  && \
    ln -sf /usr/share/zoneinfo/Asia/Shanghai /etc/localtime && \
    echo "Asia/Shanghai" > /etc/timezone

#声明要暴露的端口
EXPOSE 8081  5005

#入口
#ENTRYPOINT ["java","-Dfile.encoding=UTF-8","-jar","/app.jar"]

#入口，开启远程调试(5005端口)
ENTRYPOINT ["java","-Dfile.encoding=UTF-8","-Djava.security.egd=file:/dev/./urandom",\
   "-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=5005","-jar","/app.jar"]

在idea中，编辑一个configuration (run/debug--》edit configuration)  

完成后，我们编写好项目代码，先执行mvn clean package ，将项目打包，再找到docker-demo1 的运行选项 ，点击绿色三角启动按钮执行，即可将我们的springboot jar包，并自动构建docker镜像上传到我们的指定的docker主机上。

 

方式二 ：pom中引入一个docker插件进行项目docker远程部署

1、pom.xml   配置

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.1.7.RELEASE</version>
    <relativePath/> <!-- lookup parent from repository -->
  </parent>
  <groupId>com.tingcream</groupId>
  <artifactId>docker-demo1</artifactId>
  <version>0.1</version>
  <name>docker-demo1</name>
  <description>Demo project for Spring Boot</description>

  <properties>
    <java.version>1.8</java.version>
  </properties>

  <dependencies>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-devtools</artifactId>
      <scope>runtime</scope>
      <optional>true</optional>
    </dependency>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-test</artifactId>
      <scope>test</scope>
    </dependency>
  </dependencies>

  <build>
    <finalName>docker-demo1</finalName>
    <resources>
      <resource>
        <directory>src/main/java</directory>
        <includes>
          <include>**/*</include>
        </includes>
        <excludes>
          <exclude>**/*.java</exclude>
        </excludes>
      </resource>
      <resource>
        <directory>src/main/resources</directory>
        <includes>
          <include>**/*</include>
        </includes>
        <excludes>
          <exclude>**/*.java</exclude>
        </excludes>
      </resource>
    </resources>

    <plugins>
       <!--springboot 打execute jar包-->
      <plugin>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-maven-plugin</artifactId>
      </plugin>

       <!--JDK8 编译-->
      <plugin>
      <groupId>org.apache.maven.plugins</groupId>
      <artifactId>maven-compiler-plugin</artifactId>
      <configuration>
        <target>1.8</target>
        <source>1.8</source>
        <encoding>utf-8</encoding>
      </configuration>
      </plugin>



      <!--docker 的maven插件 -->
      <plugin>
        <groupId>com.spotify</groupId>
        <artifactId>docker-maven-plugin</artifactId>
          <version>0.4.13</version>
        <executions>
          <execution>
            <phase>package</phase>
            <goals>
              <goal>build</goal>
            </goals>
          </execution>
        </executions>
        <configuration>
          <!--docker主机的地址-->
          <dockerHost>http://192.168.11.10:2375</dockerHost>
          <!--打包的镜像名称-->
          <imageName>jellyflu/${project.build.finalName}:${version}</imageName>
          <!--Dockerfile所在的目录-->
           <dockerDirectory>${project.basedir}/src/main/docker</dockerDirectory>
        <!--<dockerDirectory>${project.basedir}</dockerDirectory>-->
         <resources>
            <resource>
              <targetPath>/</targetPath>
              <directory>${project.build.directory}</directory>
              <include>${project.build.finalName}.jar</include>
            </resource>
          </resources>
        </configuration>
      </plugin>

    </plugins>
  </build>

</project>

如上，其中最主要的就是引入了一个docker 的maven插件包，该插件包会将我们的docker build命令绑定到maven的package执行阶段。

也就是说，当我们在项目中执行mvn clean package 时，会先自动打包(springboot 包)，再远程连接到docker主机上进行镜像的构建。

2、在项目根src/main中创建docker目录，里面再新建一个Dockerfile文件。

Dockerfile文件的内容如下： 

FROM    frolvlad/alpine-oraclejre8
VOLUME /tmp
 
ENV LANG="en_US.UTF-8" \
    LANGUAGE="en_US:en"  \
    LC_ALL="en_US.UTF-8"
 
#ENV LANG en_US.UTF-8
#ENV LANGUAGE en_US:en
#ENV LC_ALL en_US.UTF-8
 
ADD  docker-demo1.jar   /app.jar
 
# 修改容器时区为北京时间
RUN  sed -i 's/dl-cdn.alpinelinux.org/mirrors.ustc.edu.cn/g' /etc/apk/repositories &&\
    apk --no-cache add tzdata  && \
    ln -sf /usr/share/zoneinfo/Asia/Shanghai /etc/localtime && \
    echo "Asia/Shanghai" > /etc/timezone
 
#声明要暴露的端口
EXPOSE 8081  5005
 
#入口
#ENTRYPOINT ["java","-Dfile.encoding=UTF-8","-jar","/app.jar"]
#入口，开启远程调试
ENTRYPOINT ["java","-Dfile.encoding=UTF-8","-Djava.security.egd=file:/dev/./urandom",\
   "-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=5005","-jar","/app.jar"]

3、编写好项目代码后，运行mvn clean package 即可自动将项目打包，并将springboot包构建为docker镜像。 注意这时镜像并没有自动run出一个容器，需要我们手动到docker主机上执行docker run命令，如

  docker run -d -p 8081:8081 -p 5005:5005  -v /log:/log --name docker-demo1   jellyflu/docker-demo1:0.1 

查看容器运行日志 :

docker  logs -f  docker-demo1  或者 tail -f /log/docker-demo1.log  

 

----------------------------------

附： docker主机上如何开启远程访问 

1、修改docker.service配置文件
 vi /usr/lib/systemd/system/docker.service 

[Service]
ExecStart=/usr/bin/dockerd -H tcp://0.0.0.0:2375 -H unix://var/run/docker.sock

:x保存退出

2、重启docker的守护进程
systemctl daemon-reload
systemctl restart docker