Spring Boot用Docker部署（spring boot docker部署）

25-02-18 22

本文将分享SpringBoot用Docker部署的详细内容，并且还将对springbootdocker部署进行详尽解释，此外，我们还将为大家带来关于Docker-Docker部署SpringBoot项

本文将分享Spring Boot用Docker部署的详细内容，并且还将对spring boot docker部署进行详尽解释，此外，我们还将为大家带来关于Docker-Docker部署SpringBoot项目、docker部署spring bootvue项目、docker部署springboot三种方式、Docker部署SpringBoot项目的相关知识，希望对你有所帮助。

本文目录一览：

Spring Boot用Docker部署（spring boot docker部署）
Docker-Docker部署SpringBoot项目
docker部署spring bootvue项目
docker部署springboot三种方式
Docker部署SpringBoot项目

Spring Boot用Docker部署（spring boot docker部署）

Spring Boot与Docker部署

开启Docker远程访问

　　首先需要开启docker远程访问功能，以便可以进行远程操作。

CentOS 6

　　修改/etc/default/docker文件，重启后生效（service docker restart）。

DOCKER_OPTS="-H=unix:///var/run/docker.sock -H=0.0.0.0:2375"

CentOS 7

　　打开/usr/lib/systemd/system/docker.service文件，修改ExecStart这行。

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

　　重启后生效

systemctl daemon-reload    
  systemctl restart docker.service

　　测试是否生效

curl http://127.0.0.1:2375/info

docker-maven-plugin插件将项目编译为docker镜像到远程linux服务器

新建Maven工程

　　pom.xml配置如下:

<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>
    <groupId>test.springboot.docker</groupId>
    <artifactId>docker-springboot</artifactId>
    <version>0.0.1-SNAPSHOT</version>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.3.RELEASE</version>
        <docker.image.prefix>springboot</docker.image.prefix>
    </parent>

    <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-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
            <plugin>
                <groupId>com.spotify</groupId>
                <artifactId>docker-maven-plugin</artifactId>
                <version>0.4.14</version>
                <configuration>
                    <imageName>${docker.image.prefix}/${project.artifactId}</imageName>
                    <dockerDirectory>src/main/docker</dockerDirectory>
                    <dockerHost>http://192.168.1.200:2375</dockerHost>
                    <resources>
                        <resource>
                            <targetPath>/</targetPath>
                            <directory>${project.build.directory}</directory>
                            <include>${project.build.finalName}.jar</include>
                        </resource>
                    </resources>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

imageName：指定了镜像的名字

dockerDirectory：指定Dockerfile的位置

dockerHost：指定Docker远程API地址

resources：指那些需要和Dockerfile放在一起，在构建镜像时使用的文件，一般应用jar包需要纳入

　　创建Java类

package hello;

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;

@SpringBootApplication
@RestController
public class Application {

    @RequestMapping("/")
    public String home() {
        return "Hello Docker World";
    }

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }

}

　　创建Dockerfile

　　在src/main/docker目录下创建一个名为Dockerfile的文件，配置如下：

FROM java
VOLUME /tmp
ADD docker-springboot-0.0.1-SNAPSHOT.jar app.jar
RUN bash -c ''touch /app.jar''
ENV JAVA_OPTS=""
ENTRYPOINT [ "sh", "-c", "java $JAVA_OPTS -Djava.security.egd=file:/dev/./urandom -jar /app.jar" ]

FROM java：指Docker Hub上官方提供的java镜像，有了这个基础镜像后，Dockerfile可以通过FROM指令直接获取它的状态——也就是在容器中java是已经安装的，接下来通过自定义的命令来运行Spring Boot应用。

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

ADD docker-springboot-0.0.1-SNAPSHOT.jar app.jar：将应用jar包复制到/app.jar

ENTRYPOINT：表示容器运行后默认执行的命令

RUN为初始化时运行的命令

ENV为设置环境变量

完整目录结构如下所示：

　　运行以下命令创建Docker镜像：

package docker:build

Docker启动镜像

　　查看项目是否上传成功

　　启动镜像

docker run -p 8888:8080 springboot/docker-springboot

　　通过浏览器访问

Docker-Docker部署SpringBoot项目

1.1.准备Springboot jar项目#

在这里插入图片描述将项目打包成jar

1.2.编写Dockerfile#

FROM java:8
VOLUME /tmp
ADD elk-web-1.0-SNAPSHOT.jar elk.jar
EXPOSE 8080
ENTRYPOINT ["java","-Djava.security.egd=file:/dev/./urandom","-jar","/elk.jar"]

FROM：表示基础镜像，即运行环境 VOLUME /tmp创建/tmp目录并持久化到Docker数据文件夹，因为Spring Boot使用的内嵌Tomcat容器默认使用/tmp作为工作目录 ADD：拷贝文件并且重命名(ADD elk-web-1.0-SNAPSHOT.jar elk.jar 将应用jar包复制到/elk.jar) EXPOSE：并不是真正的发布端口，这个只是容器部署人员与建立image的人员之间的交流，即建立image的人员告诉容器布署人员容器应该映射哪个端口给外界 ENTRYPOINT：容器启动时运行的命令，相当于我们在命令行中输入java -jar xxxx.jar，为了缩短 Tomcat 的启动时间，添加java.security.egd的系统属性指向/dev/urandom作为 ENTRYPOINT

1.3.构建容器#

[root@VM_0_15_centos elk]# docker build -t elk .
Sending build context to Docker daemon 14.43 MB
Step 1/5 : FROM java:8
Trying to pull repository docker.io/library/java ... 
8: Pulling from docker.io/library/java
5040bd298390: Pull complete 
fce5728aad85: Pull complete 
76610ec20bf5: Pull complete 
60170fec2151: Pull complete 
e98f73de8f0d: Pull complete 
11f7af24ed9c: Pull complete 
49e2d6393f32: Pull complete 
bb9cdec9c7f3: Pull complete 
Digest: sha256:c1ff613e8ba25833d2e1940da0940c3824f03f802c449f3d1815a66b7f8c0e9d
Status: Downloaded newer image for docker.io/java:8
 ---> d23bdf5b1b1b
Step 2/5 : VOLUME /tmp
 ---> Running in 0aec2dc2f98c
 ---> a52e844f25d4
Removing intermediate container 0aec2dc2f98c
Step 3/5 : ADD elk-web-1.0-SNAPSHOT.jar elk.jar
 ---> 3ba2f4fdddda
Removing intermediate container 860a0f748a23
Step 4/5 : EXPOSE 8080
 ---> Running in 1d3331cc2be6
 ---> e9ac33d26ce0
Removing intermediate container 1d3331cc2be6
Step 5/5 : ENTRYPOINT java -Djava.security.egd=file:/dev/./urandom -jar /elk.jar
 ---> Running in d354f8ee2af5
 ---> 8937e1ade6c7
Removing intermediate container d354f8ee2af5
Successfully built 8937e1ade6c7

1.4.运行容器#

docker run -di --name 容器名称 -p 8080:8080 镜像名称

其中-d表示后台运行容器，这也就自然地解决的Spring Boot不支持后台运行应用程序的问题。 -p 8080:8080表示将容器内部的8080端口映射到宿主机器的8080端口，这样就可以通过宿主机器直接访问应用。 --name 给容器取一个容易记住的名字方便日后管理。

[root@VM_0_15_centos elk]# docker run -di --name myspringboot -p 8080:8080 8937e1ade6c7
04d6b2c347950a10c95a039c94a3e51d717e516dd8c3c742e3197687dfcf5523
[root@VM_0_15_centos elk]# docker ps -a
CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS                    NAMES
04d6b2c34795        8937e1ade6c7        "java -Djava.secur..."   8 seconds ago       Up 7 seconds        0.0.0.0:8080->8080/tcp   myspringboot
[root@VM_0_15_centos elk]#

1.5.查看运行日志#

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

[root@VM_0_15_centos elk]# docker logs -f --tail=100 04d6b2c34795
  .   ____          _            __ _ _
 / / ___''_ __ _ _(_)_ __  __ _    
( ( )___ | ''_ | ''_| | ''_ / _` |    
 /  ___)| |_)| | | | | || (_| |  ) ) ) )
  ''  |____| .__|_| |_|_| |___, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::        (v1.5.4.RELEASE)
2019-12-29 07:42:58.982  INFO 1 --- [           main] c.b.ElkExampleSpringBootApplication      : Starting ElkExampleSpringBootApplication v1.0-SNAPSHOT on 04d6b2c34795 with PID 1 (/elk.jar started by root in /)
2019-12-29 07:42:58.999  INFO 1 --- [           main] c.b.ElkExampleSpringBootApplication      : No active profile set, falling back to default profiles: default
2019-12-29 07:42:59.243  INFO 1 --- [           main] ationConfigEmbeddedWebApplicationContext : Refreshing org.springframework.boot.context.embedded.AnnotationConfigEmbeddedWebApplicationContext@5a2e4553: startup date [Sun Dec 29 07:42:59 UTC 2019]; root of context hierarchy
2019-12-29 07:43:03.652  INFO 1 --- [           main] s.b.c.e.t.TomcatEmbeddedServletContainer : Tomcat initialized with port(s): 8080 (http)
2019-12-29 07:43:03.699  INFO 1 --- [           main] o.apache.catalina.core.StandardService   : Starting service [Tomcat]
2019-12-29 07:43:03.714  INFO 1 --- [           main] org.apache.catalina.core.StandardEngine  : Starting Servlet Engine: Apache Tomcat/8.5.15
2019-12-29 07:43:04.012  INFO 1 --- [ost-startStop-1] o.a.c.c.C.[Tomcat].[localhost].[/]       : Initializing Spring embedded WebApplicationContext
2019-12-29 07:43:04.012  INFO 1 --- [ost-startStop-1] o.s.web.context.ContextLoader            : Root WebApplicationContext: initialization completed in 4772 ms
2019-12-29 07:43:04.449  INFO 1 --- [ost-startStop-1] o.s.b.w.servlet.ServletRegistrationBean  : Mapping servlet: ''dispatcherServlet'' to [/]
2019-12-29 07:43:04.470  INFO 1 --- [ost-startStop-1] o.s.b.w.servlet.FilterRegistrationBean   : Mapping filter: ''characterEncodingFilter'' to: [/*]
2019-12-29 07:43:04.470  INFO 1 --- [ost-startStop-1] o.s.b.w.servlet.FilterRegistrationBean   : Mapping filter: ''hiddenHttpMethodFilter'' to: [/*]
2019-12-29 07:43:04.471  INFO 1 --- [ost-startStop-1] o.s.b.w.servlet.FilterRegistrationBean   : Mapping filter: ''httpPutFormContentFilter'' to: [/*]
2019-12-29 07:43:04.471  INFO 1 --- [ost-startStop-1] o.s.b.w.servlet.FilterRegistrationBean   : Mapping filter: ''requestContextFilter'' to: [/*]
2019-12-29 07:43:05.534  INFO 1 --- [           main] s.w.s.m.m.a.RequestMappingHandlerAdapter : Looking for @ControllerAdvice: org.springframework.boot.context.embedded.AnnotationConfigEmbeddedWebApplicationContext@5a2e4553: startup date [Sun Dec 29 07:42:59 UTC 2019]; root of context hierarchy
2019-12-29 07:43:05.765  INFO 1 --- [           main] s.w.s.m.m.a.RequestMappingHandlerMapping : Mapped "{[/exception]}" onto public java.lang.String com.bruceliu.controller.ELKController.exception()
2019-12-29 07:43:05.766  INFO 1 --- [           main] s.w.s.m.m.a.RequestMappingHandlerMapping : Mapped "{[/elkdemo]}" onto public java.lang.String com.bruceliu.controller.ELKController.helloWorld()
2019-12-29 07:43:05.772  INFO 1 --- [           main] s.w.s.m.m.a.RequestMappingHandlerMapping : Mapped "{[/error],produces=[text/html]}" onto public org.springframework.web.servlet.ModelAndView org.springframework.boot.autoconfigure.web.BasicErrorController.errorHtml(javax.servlet.http.HttpServletRequest,javax.servlet.http.HttpServletResponse)
2019-12-29 07:43:05.780  INFO 1 --- [           main] s.w.s.m.m.a.RequestMappingHandlerMapping : Mapped "{[/error]}" onto public org.springframework.http.ResponseEntity<java.util.Map<java.lang.String, java.lang.Object>> org.springframework.boot.autoconfigure.web.BasicErrorController.error(javax.servlet.http.HttpServletRequest)
2019-12-29 07:43:05.869  INFO 1 --- [           main] o.s.w.s.handler.SimpleUrlHandlerMapping  : Mapped URL path [/webjars/**] onto handler of type [class org.springframework.web.servlet.resource.ResourceHttpRequestHandler]
2019-12-29 07:43:05.869  INFO 1 --- [           main] o.s.w.s.handler.SimpleUrlHandlerMapping  : Mapped URL path [/**] onto handler of type [class org.springframework.web.servlet.resource.ResourceHttpRequestHandler]
2019-12-29 07:43:05.984  INFO 1 --- [           main] o.s.w.s.handler.SimpleUrlHandlerMapping  : Mapped URL path [/**/favicon.ico] onto handler of type [class org.springframework.web.servlet.resource.ResourceHttpRequestHandler]
2019-12-29 07:43:06.387  INFO 1 --- [           main] o.s.j.e.a.AnnotationMBeanExporter        : Registering beans for JMX exposure on startup
2019-12-29 07:43:06.537  INFO 1 --- [           main] s.b.c.e.t.TomcatEmbeddedServletContainer : Tomcat started on port(s): 8080 (http)
2019-12-29 07:43:06.562  INFO 1 --- [           main] c.b.ElkExampleSpringBootApplication      : Started ElkExampleSpringBootApplication in 8.771 seconds (JVM running for 9.832)

1.6.访问测试#

在这里插入图片描述

2.Docker远程连接并且使用idea一键部署#

2.1.配置docker远程连接端口#

首先编辑我们服务器上的docker文件

vim /usr/lib/systemd/system/docker.service

修改以ExecStart开头的行（centos 7）：添加

-H tcp://0.0.0.0:2375 -H unix:///var/run/docker.sock

在这里插入图片描述修改后保存文件，然后重启docker

systemctl daemon-reload
service docker restart

重启之后测试远程连接是否正常，这里的2375是之前配置的端口

curl http://localhost:2375/version

看到返回信息基本上就没有问题了

[root@VM_0_15_centos elk]# curl http://localhost:2375/version
{"Version":"1.13.1","ApiVersion":"1.26","MinAPIVersion":"1.12","GitCommit":"7f2769b/1.13.1","GoVersion":"go1.10.3","Os":"linux","Arch":"amd64","KernelVersion":"3.10.0-957.21.3.el7.x86_64","BuildTime":"2019-09-15T14:06:47.565778468+00:00","PkgVersion":"docker-1.13.1-103.git7f2769b.el7.centos.x86_64"}

然后开启端口，或者关闭防火墙，二者选其一即可

firewall-cmd --zone=public --add-port=2375/tcp --permanent

chkconfig iptables off

然后打开浏览器测试将之前的localhost修改为你的ip 在这里插入图片描述

2.2.使用idea连接到docker#

首先下载docker插件，idea2019自带了docker插件。如果没有插件可以选择安装docker插件在这里插入图片描述然后配置docker地址，在你的File | Settings | Build, Execution, Deployment | Docker配置完成链接之后，出现了框中的内容即可.链接成功之后会列出容器和镜像!

配置阿里云镜像加速器：在这里插入图片描述

2.3.docker-maven-plugin 介绍#

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

pom.xml:

<build>

        <finalName>${project.artifactId}</finalName>

        <plugins>

            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <fork>true</fork>
                </configuration>
            </plugin>
            <!-- 跳过单元测试 -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <configuration>
                    <skipTests>true</skipTests>
                </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>
                        <!--用户只需执行mvn package ，就会自动执行mvn docker:build-->
                        <phase>package</phase>
                        <goals>
                            <goal>build</goal>
                        </goals>
                    </execution>
                </executions>
                <configuration>
                    <!--指定生成的镜像名-->
                    <imageName>bruceliu/${project.artifactId}</imageName>
                    <!--指定标签-->
                    <imageTags>
                        <imageTag>latest</imageTag>
                    </imageTags>
                    <!--指定基础镜像jdk1.8-->
                    <baseImage>java</baseImage>
                    <!--镜像制作人本人信息-->
                    <maintainer>bruceliu@email.com</maintainer>
                    <!--切换到ROOT目录-->
                    <workdir>/ROOT</workdir>
                    <cmd>["java", "-version"]</cmd>
                    <entryPoint>["java", "-jar", "/${project.build.finalName}.jar"]</entryPoint>
                    <!--指定远程 docker api地址-->
                    <dockerHost>http://122.51.50.249:2375</dockerHost>
                    <!-- 这里是复制 jar 包到 docker 容器指定目录配置 -->
                    <resources>
                        <resource>
                            <targetPath>/</targetPath>
                            <!--jar 包所在的路径  此处配置的 即对应 target 目录-->
                            <directory>${project.build.directory}</directory>
                            <!--用于指定需要复制的文件 需要包含的 jar包 ，这里对应的是 Dockerfile中添加的文件名　-->
                            <include>${project.build.finalName}.jar</include>
                        </resource>
                    </resources>
                </configuration>
            </plugin>

        </plugins>
    </build>

执行Maven打包命令：在这里插入图片描述

G:softDevelopmentJDK8binjava -Dmaven.multiModuleProjectDirectory=E:workspace2017elk-web -Dmaven.home=E:Maven20190910apache-maven-3.6.1 -Dclassworlds.conf=E:Maven20190910apache-maven-3.6.1binm2.conf "-javaagent:G:idea2017IntelliJ IDEA 2017.3.1libidea_rt.jar=49260:G:idea2017IntelliJ IDEA 2017.3.1bin" -Dfile.encoding=UTF-8 -classpath E:Maven20190910apache-maven-3.6.1bootplexus-classworlds-2.6.0.jar org.codehaus.classworlds.Launcher -Didea.version=2017.3.7 -s E:Maven20190910apache-maven-3.6.1confsettings.xml -Dmaven.repo.local=E:Maven20190910repository package
[INFO] Scanning for projects...
[WARNING] 
[WARNING] Some problems were encountered while building the effective model for com.bruceliu.elk.demo:elk-web:jar:1.0-SNAPSHOT
[WARNING] ''build.plugins.plugin.(groupId:artifactId)'' must be unique but found duplicate declaration of plugin org.springframework.boot:spring-boot-maven-plugin @ line 36, column 21
[WARNING] 
[WARNING] It is highly recommended to fix these problems because they threaten the stability of your build.
[WARNING] 
[WARNING] For this reason, future Maven versions might no longer support building such malformed projects.
[WARNING] 
[INFO] 
[INFO] -------------------< com.bruceliu.elk.demo:elk-web >--------------------
[INFO] Building elk-web 1.0-SNAPSHOT
[INFO] --------------------------------[ jar ]---------------------------------
[INFO] 
[INFO] --- maven-resources-plugin:2.6:resources (default-resources) @ elk-web ---
[INFO] Using ''UTF-8'' encoding to copy filtered resources.
[INFO] Copying 1 resource
[INFO] Copying 0 resource
[INFO] 
[INFO] --- maven-compiler-plugin:3.1:compile (default-compile) @ elk-web ---
[INFO] Changes detected - recompiling the module!
[INFO] Compiling 2 source files to E:workspace2017elk-webtargetclasses
[INFO] 
[INFO] --- maven-resources-plugin:2.6:testResources (default-testResources) @ elk-web ---
[INFO] Using ''UTF-8'' encoding to copy filtered resources.
[INFO] skip non existing resourceDirectory E:workspace2017elk-websrctestresources
[INFO] 
[INFO] --- maven-compiler-plugin:3.1:testCompile (default-testCompile) @ elk-web ---
[INFO] Nothing to compile - all classes are up to date
[INFO] 
[INFO] --- maven-surefire-plugin:2.18.1:test (default-test) @ elk-web ---
[INFO] Tests are skipped.
[INFO] 
[INFO] --- maven-jar-plugin:2.6:jar (default-jar) @ elk-web ---
[INFO] Building jar: E:workspace2017elk-webtargetelk-web.jar
[INFO] 
[INFO] --- spring-boot-maven-plugin:1.5.4.RELEASE:repackage (default) @ elk-web ---
[INFO] 
[INFO] --- docker-maven-plugin:1.0.0:build (build-image) @ elk-web ---
[INFO] Using authentication suppliers: [ConfigFileRegistryAuthSupplier]
[INFO] Copying E:workspace2017elk-webtargetelk-web.jar -> E:workspace2017elk-webtargetdockerelk-web.jar
[INFO] Building image bruceliu/elk-web
Step 1/6 : FROM java
 ---> d23bdf5b1b1b
Step 2/6 : MAINTAINER bruceliu@email.com
 ---> Running in 787e4786fbd4
 ---> 4d4519f52fda
Removing intermediate container 787e4786fbd4
Step 3/6 : WORKDIR /ROOT
 ---> f40dcbc9a9eb
Removing intermediate container 7fa6bbc9d1df
Step 4/6 : ADD /elk-web.jar //
 ---> c7f1107ae3d4
Removing intermediate container f370558f1a38
Step 5/6 : ENTRYPOINT java -jar /elk-web.jar
 ---> Running in e4480ced0829
 ---> b634ca5fa5ad
Removing intermediate container e4480ced0829
Step 6/6 : CMD java -version
 ---> Running in cc6a064ef921
 ---> cf9a5d50326b
Removing intermediate container cc6a064ef921
Successfully built cf9a5d50326b
[INFO] Built bruceliu/elk-web
[INFO] Tagging bruceliu/elk-web with latest
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time:  10.329 s
[INFO] Finished at: 2019-12-29T22:44:06+08:00
[INFO] ------------------------------------------------------------------------

Process finished with exit code 0

docker部署spring bootvue项目

Vue项目

我们先建立一个项目的文件目录，比如
然后在该目录下创建vue工程
vue工程的创建我就不赘述了，网上教程一大把。这里提一下的是，我们需要的是vue项目build后的静态文件，将其放在nginx目录下。

vue工程创建好后，cd到工程目录，修改你的前端代码，这里我们只是为了尝试docker运行vue项目build的文件，所以就用默认的代码，npm run build打包项目

nginx配置

我们从docker hub上面进行nginx的拉取，通过docker pull nginx进行拉取，拉取完后，可通过命令docker image ls 命令来查看本地已存在的镜像列表，会发现多了个nginx镜像

可以在项目(vue-test/vue工程目录)的根目录新增一个nginx.conf文件，和nginx目录下配置文件一样，可以修改自定义配置
不用配置也可以，就会使用nginx默认配置，默认80端口、静态页目录ngnix/html

Dockerfile

项目(vue-test/vue工程目录)的根目录增加一个Dockerfile文件
mkdir Dockerfile
然后vi Dockerfile编辑内容如下:

FROM nginx  #指定基础镜像，即运行环境
COPY dist/ /usr/share/nginx/html/   #copy dist/ 到镜像内/usr/share/nginx/html/下

然后在该目录下运行
docker build -t 自定义镜像名 .
构建一个新镜像，如果本地不存在指定的基础镜像，docker会自动拉取，这里等待完成即可
完成后输入docker images会发现镜像列表多了一个刚刚自定义名字的镜像

最后docker run --name 自定义容器名 -p8080:80 -d 自定义镜像名运行一个容器，之后打开对应地址8080端口就可以访问这个项目了

docker运行springboot项目

参考资料

然后我尝试着docker运行了一个springboot，具体步骤大同小异，这里简述一下，首先我在本地机器（docker部署在远程服务器上）创建了一个springboot项目，简单的写了一个接口，然后通过maven打成jar包，然后xshell上传到服务器，在该目录下创建Dockerfile：

FROM java:8
VOLUME /tmp
ADD movie-0.0.1-SNAPSHOT.jar app.jar 
EXPOSE 8080
ENTRYPOINT ["java","-Djava.security.egd=file:/dev/./urandom","-jar","/app.jar"]

说明：

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

VOLUME：一个特别指定的目录，用于存储数据，该命令的作用是在/var/lib/docker创建一个名为tmp的目录，在开启redis服务时，需要特别指定redis的数据存储在哪个文件夹，此时这个命令就十分有用

ADD：拷贝文件并且重命名

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

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

然后执行上文提到的命令

docker build -t 自定义镜像名 .
docker run --name 自定义容器名 -p8081:8080 -d 自定义镜像名

之后访问8081端口，正确显示了接口返回

docker部署springboot三种方式

项目源码网址:

https://gitee.com/shao_ming314/note/tree/master/%E8%84%9A%E6%89%8B%E6%9E%B6-%E7%9B%B4%E6%8E%A5%E7%94%A8/docker%E9%83%A8%E7%BD%B2springboot%E7%9A%843%E7%A7%8D%E6%96%B9%E5%BC%8F

本文参考网址:

https://mp.weixin.qq.com/s/k5gjh3YEMKYt70vvnGtqDg

准备工作

创建一个springboot项目spring-boot-docker

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>
	<groupId>com.neo</groupId>
	<artifactId>spring-boot-docker</artifactId>
	<version>1.0</version>
	<packaging>jar</packaging>
	<name>spring-boot-docker</name>
	<description>Demo project for Spring Boot</description>
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.0.0.RELEASE</version>
	</parent>
	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<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-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
	</dependencies>
	<build>
		<finalName>${project.artifactId}</finalName>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
				<configuration>
					<fork>true</fork>
				</configuration>
			</plugin>
			<!-- 跳过单元测试 -->
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-surefire-plugin</artifactId>
				<configuration>
					<skipTests>true</skipTests>
				</configuration>
			</plugin>
		</plugins>
	</build>
</project>

application.properties

server.port=8081

新建一个测试的controller

@Controller
public class HelloController {
    @Value("${server.port}")
    private String port;
         @GetMapping("/")//get请求
         @ResponseBody
         public String hello() {
         System.out.println("hello docker,该项目的端口好为:"+port);
             return "hello docker,该项目的端口好为:"+port;
         }
}

启动项目测试

第一种方式

不使用插件和idea

初始化项目目录如下

1.项目打包

项目根目录执行命令:

mvn clean package

2.在项目根目录添加Dockerfile文件

Dockfile

FROM java:8
VOLUME /tmp
ADD target/spring-boot-docker-1.0.jar  app.jar
ENTRYPOINT ["java","-Djava.security.egd=file:/dev/./urandom","-jar","/app.jar"]

3.构建镜像

在项目根目录执行命令

docker build -t app .

4.运行容器

使用docker命令:

# 查看镜像
docker images
# 运行容器
docker run --name myboot -p 8081:8081 -itd app
# 查看容器日志
docker logs -f myboot

5.测试访问

启动项目测试

容器中的日志如下

第二种方式(使用maven插件)

1.在相应位置编写dockerfile

在项目的/src/main目录下新建docker文件夹,在里面添加dockerfile文件

文件内容如下:

Dockerfile

FROM java:8
COPY *.jar /app.jar
ENTRYPOINT ["java", "-jar", "/app.jar"]

2.编辑修改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>

        <groupId>com.neo</groupId>
        <artifactId>spring-boot-docker</artifactId>
        <version>1.0</version>
        <packaging>jar</packaging>

        <name>spring-boot-docker</name>
        <description>Demo project for Spring Boot</description>

        <parent>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-parent</artifactId>
                <version>2.0.0.RELEASE</version>
        </parent>

        <properties>
                <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
                <java.version>1.8</java.version>
                <docker.image.prefix>springboot</docker.image.prefix>
        </properties>

        <dependencies>
             <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
                <dependency>
                        <groupId>org.springframework.boot</groupId>
                        <artifactId>spring-boot-starter-test</artifactId>
                        <scope>test</scope>
                </dependency>
        </dependencies>
        
        <build>
                <plugins>
                        <plugin>
                                <groupId>org.springframework.boot</groupId>
                                <artifactId>spring-boot-maven-plugin</artifactId>
                        </plugin>
                        <!-- Docker maven plugin -->
                        <plugin>
                                <groupId>com.spotify</groupId>
                                <artifactId>docker-maven-plugin</artifactId>
                                <version>1.0.0</version>
                                <configuration>
        <imageName>${docker.image.prefix}/${project.artifactId}</imageName>
                                        <dockerDirectory>src/main/docker</dockerDirectory>
                                        <resources>
                                                <resource>
                                                        <targetPath>/</targetPath>
                                                        <directory>${project.build.directory}</directory>
                                                        <include>${project.build.finalName}.jar</include>
                                                </resource>
                                        </resources>
                                </configuration>
                        </plugin>
                        <!-- Docker maven plugin -->
                </plugins>
        </build>

</project>

3.构建镜像

使用mavne的docker插件构建镜像

mvn package docker:build

4.运行容器

使用docker命令:

# 查看镜像
docker images
# 运行容器
docker run --name myboot -p 8081:8081 -itd  springboot/spring-boot-docker
# 查看容器日志
docker logs -f myboot

5.测试访问

启动项目测试

容器中的日志如下

第三种方式(推荐):整合idea

1.开启docker远程访问

修改docker的/usr/lib/systemd/system/docker.service配置文件

vim /usr/lib/systemd/system/docker.service

老版本docker开启远程访问需要添加如下配置

-H tcp://0.0.0.0:2375 -H unix:///var/run/docker.sock \

新版本docker开启远程访问需要添加如下配置

-H tcp://0.0.0.0:2375 -H unix:///var/run/docker.sock

配置完成后，保存退出，然后重启 Docker：(一定要重启,否则会不生效)

systemctl daemon-reload

service docker restart

Docker 重启成功之后，Docker 的准备工作就算是 OK 了。

测试docker是否开启远程访问

测试是否可以远程访问:宿主机浏览器访问 ip:2375/version

出现如上信息,证明docker开启远程访问成功

2.配置idea

IDEA 上的准备工作，主要是安装一个 Docker 插件，点击 File->Settings->Plugins->Browse Repositories 如下：

说明:

新版本的idea都是内置了docker插件

配置docker连接信息

配置docker加速镜像地址

3.在项目根目录编写dockerfile

FROM java:8
VOLUME /tmp
ADD target/spring-boot-docker.jar app.jar
ENTRYPOINT ["java","-jar","/app.jar"]

4.配置maven插件

配置好的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>

    <groupId>com.neo</groupId>
    <artifactId>spring-boot-docker</artifactId>
    <version>1.0</version>
    <packaging>jar</packaging>

    <name>spring-boot-docker</name>
    <description>Demo project for Spring Boot</description>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.0.RELEASE</version>
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <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-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <finalName>${project.artifactId}</finalName>

        <plugins>

            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <fork>true</fork>
                </configuration>
            </plugin>
            <!-- 跳过单元测试 -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <configuration>
                    <skipTests>true</skipTests>
                </configuration>
            </plugin>

            <plugin>
                <groupId>com.spotify</groupId>
                <artifactId>docker-maven-plugin</artifactId>
                <version>1.2.0</version>
                <executions>
                    <execution>
                        <id>build-image</id>
                        <phase>package</phase>
                        <goals>
                            <goal>build</goal>
                        </goals>
                    </execution>
                </executions>
                <configuration>
                    <!--配置docker的连接信息-->
                    <dockerHost>http://192.168.66.78:2375</dockerHost>
                    <!-- 配置镜像的名称 -->
                    <imageName>shaoming/${project.artifactId}</imageName>
                    <imageTags>
                        <imageTag>${project.version}</imageTag>
                    </imageTags>
                    <!--build 时强制覆盖 tag，配合 imageTags 使用-->
                    <forceTags>true</forceTags>
                    <!-- 指定 Dockerfile 路径-->
                    <dockerDirectory>${project.basedir}</dockerDirectory>
                    <resources>
                        <!-- 这里是复制 jar 包到 docker 容器指定目录配置，也可以写到 Docokerfile 中 -->
                        <resource>
                            <targetPath>/</targetPath>
                            <directory>${project.build.directory}</directory>
                            <include>${project.build.finalName}.jar</include>
                        </resource>
                    </resources>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

5.构建镜像

接下来对项目进行打包，打包完成后，项目会自动构建成一个镜像，并且上传到 Docker 容器中，打包方式如下：

打包过程会稍微有一点旧，因为还包含了镜像的构建，特别是第一次打包，需要下载基础镜像，会更慢一些。

部分打包日志如下（项目构建过程）:

项目打包成功之后，我们就可以在 Docker 容器中看到我们刚刚打包成的镜像了，如下：

6.运行容器

6.1运行方式一

使用docker命令:

# 查看镜像
docker images
# 运行容器
docker run --name myboot -p 8081:8081 -itd  shaoming/spring-boot-docker:latest
# 查看容器日志
docker logs -f myboot

6.2 运行方式二

此时我们的 IDEA 中多了一个选项，就是 docker，如下：

说明:

每个idea版本都有差异,所以docker插件配置可能也有差异

点击左边的绿色启动按钮，连接上 Docker 容器，连接成功之后，我们就可以看到目前 Docker 中的所有容器和镜像了，当然也包括我们刚刚创建的 Docker 镜像，如下：

右键创建容器

配置容器的相关信息

7.测试访问

启动项目测试

容器中的日志如下

est

查看容器日志

docker logs -f myboot


#### **6.2** **运行方式二**

此时我们的 IDEA 中多了一个选项，就是 docker，如下：

说明:

> 每个idea版本都有差异,所以docker插件配置可能也有差异

[外链图片转存中...(img-fPHxV1xX-1618906137998)]

点击左边的绿色启动按钮，连接上 Docker 容器，连接成功之后，我们就可以看到目前 Docker 中的所有容器和镜像了，当然也包括我们刚刚创建的 Docker 镜像，如下：

[外链图片转存中...(img-NbuiowF5-1618906137999)]

右键创建容器

[外链图片转存中...(img-bfQfDubr-1618906138000)]

配置容器的相关信息

[外链图片转存中...(img-yI2bvduJ-1618906138001)]

### 7.测试访问

启动项目测试

[外链图片转存中...(img-z5IzRv7s-1618906138002)]

容器中的日志如下

![image-20210420150848518](https://img-blog.csdnimg.cn/img_convert/8da294d36fe8d38db372a485ccc00ef4.png)

Docker部署SpringBoot项目

1.准备一个SpringBoot项目

2.安装Docker

Docker运行在CentOS 7上，要求操作系统为64位，内核版本为3.10及以上。
确认本机已经安装了满足要求的Linux内核。使用命令uname -r来检查内核版本信息。

[root@localhost ~]# uname -r
3.10.0-957.el7.x86_64

安装Docker

使用命令yum install -y docker安装Docker，“-y”表示不询问，使用默认配置进行安装。

启动Docker服务，并设置为开机自启动

#启动
systemctl start docker.service

#开启自启动
systemctl enable docker.service

#查看docker版本
docker version

3.配置DockerFile文件

新建文件夹并创建对应文件

cd /home

mkdir DockerDeploy

cd DockerDeploy

touch Dockerfile   #插入如下内容

FROM java:8

VOLUME /tmp

ADD my-blog-4.0.0-SNAPSHOT.jar app.jar

RUN bash -c "touch /app.jar"

EXPOSE 8080

ENTRYPOINT ["java","-Djava.security.egd=file:/dev/./urandom","-jar","/app.jar"]

Remark:

FROM指令指定一个已经存在的镜像，告诉Docker后续的指令都是在这个基础上进行的。例如：FROM java:8表示使用 Jdk1.8 环境为基础镜像进行构建镜像。

VOLUME ，VOLUME 指向了一个/tmp的目录，由于Spring Boot使用内置的Tomcat容器，Tomcat 默认使用/tmp作为工作目录。这个命令的效果是：在宿主机的/var/lib/docker目录下创建一个临时文件并把它链接到容器中的/tmp目录

ADD ，拷贝文件并且重命名

ENTRYPOINT，为了缩短Tomcat 的启动时间，添加java.security.egd的系统属性指向/dev/urandom作为ENTRYPOINT

4.上传jar包(上传步骤一中准备好的jar包)

5.构建镜像(镜像名需要小写)

Remark:第一次构建会耗时比较久

# 构建镜像
docker build -t blog .

6.检查镜像

docker images

7.构建容器并运行

docker run -d --name=myblog -p 8080:8080 blog

#查看容器
docker ps

#查看日志
docker logs -f id

解释说明：

run: 容器启动命令

--name boot-docker 自定义容器命名

-d 程序后台启动

-v /opt/jar/boot-docker/logs:/log 应用日志数据卷的方式存储

-p 8000:8000 用主机8000端口映射容器端口

boot-docker 镜像名称

8.访问检测正常

9.打tag，推送到私人仓库，下次直接拉取使用

我们今天的关于Spring Boot用Docker部署和spring boot docker部署的分享已经告一段落，感谢您的关注，如果您想了解更多关于Docker-Docker部署SpringBoot项目、docker部署spring bootvue项目、docker部署springboot三种方式、Docker部署SpringBoot项目的相关信息，请在本站查询。

本文标签：