在这篇文章中，我们将为您详细介绍Docker+SpringBootexamples的内容。此外，我们还会涉及一些关于62-docker-compose结合dockerfile部署springboot应

在这篇文章中，我们将为您详细介绍Docker + Spring Boot examples的内容。此外，我们还会涉及一些关于62-docker-compose 结合 dockerfile 部署 springboot 应用、62-docker-compose 结合dockerfile 部署springboot应用、docker - dockerfile构建一个简单的springboot应用镜像、Docker Spring boot 项目使用 docker-maven-plugin 执行mvn docker:build 打成镜像的知识，以帮助您更全面地了解这个主题。

• Docker + Spring Boot examples
• 62-docker-compose 结合 dockerfile 部署 springboot 应用
• 62-docker-compose 结合dockerfile 部署springboot应用
• docker - dockerfile构建一个简单的springboot应用镜像
• Docker Spring boot 项目使用 docker-maven-plugin 执行mvn docker:build 打成镜像

Docker + Spring Boot examples

https://mkyong.com/docker/docker-spring-boot-examples/

In this tutorial, we will show you how to Dockerize a Spring Boot web application (mvc + thymeleaf).

Tested with

• Docker 19.03
• Ubuntu 19
• Java 8 or Java 11
• Spring Boot 2.2.4.RELEASE
• Maven

At the end of the article, we will create a Spring Boot MVC web application and run inside a docker container.

P.S This example is tested with Java 8 and Java 11.

1. Project Directory

1.1 A standard Maven project structure.

See the Dockerfile at the root of the project? We only need this Dockerfile text file to dockerize the Spring Boot application.

2. Maven

2.1 Project dependencies. Nothing special here, just some Spring Boot dependencies.

<?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.mkyong</groupId>
    <artifactId>docker-spring-boot</artifactId>
    <version>1.0</version>

    <name>docker-spring-boot</name>
    <url></url>

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

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>11</maven.compiler.source>
        <maven.compiler.target>11</maven.compiler.target>
        <java.version>11</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-thymeleaf</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <!-- debugging -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <optional>true</optional>
        </dependency>

    </dependencies>

    <build>
        <finalName>spring-boot-web</finalName>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.0</version>
                <configuration>
                    <source>${java.version}</source>
                    <target>${java.version}</target>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

3. Spring Boot

3.1 @SpringBootApplication to start everything, and also a controller to return a page.

package com.mkyong;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;

@SpringBootApplication
@Controller
public class StartApplication {

    @GetMapping("/")
    public String index(final Model model) {
        model.addAttribute("title", "Docker + Spring Boot");
        model.addAttribute("msg", "Welcome to the docker container!");
        return "index";
    }

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

}

3.2 A thymeleaf page.

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="utf-8">
    <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/4.4.1/css/bootstrap.min.css"/>
    <link data-th-href="@{/css/main.css?{id}(id=${timestamp})}" rel="stylesheet">
    <title>Hello Docker + Spring Boot</title>
</head>
<body>

<nav class="navbar navbar-expand-md navbar-dark bg-dark fixed-top">
    <a class="navbar-brand" href="#">Mkyong.com</div></a>
</nav>

<main role="main" class="container">
    <div class="starter-template">
        <h1 th:text="${title}">Default title.</h1>
        <p th:text="${msg}">Default text.</p>
    </div>
</main>

<script data-th-src="@{/js/main.js}"></script>
</body>

</html>

4. Run Spring Boot

4.1 Done, package it with Maven.

$ cd project
$ mvn clean package

4.2 Run the Spring Boot.

$ cd project
$ java -jar target/spring-boot-web.jar

Done, next, we will start this target/spring-boot-web.jar in a docker container.

4. Docker File

A Dockerfile is a text file, contains all the commands to assemble the docker image. Review the commands in the Dockerfile:

4.1 It creates a docker image base on adoptopenjdk/openjdk11:alpine-jre, an alpine linux with openjdk11 installed. This base image adoptopenjdk/openjdk11:alpine-jre is just an example, we can find more base images from the official Docker Hub

# For Java 8, try this
# FROM openjdk:8-jdk-alpine

# For Java 11, try this
FROM adoptopenjdk/openjdk11:alpine-jre

4.2 Changed the working directory to /opt/app

WORKDIR /opt/app

4.3 Copy spring-boot-web.jar to /opt/app/app.jar

ARG JAR_FILE=target/spring-boot-web.jar

# cp spring-boot-web.jar /opt/app/app.jar
COPY ${JAR_FILE} app.jar

4.4 Run the jar file with ENTRYPOINT.

# java -jar /opt/app/app.jar
ENTRYPOINT ["java","-jar","app.jar"]

4.5 A complete Dockerfile example.

# For Java 8, try this
# FROM openjdk:8-jdk-alpine

# For Java 11, try this
FROM adoptopenjdk/openjdk11:alpine-jre

# Refer to Maven build -> finalName
ARG JAR_FILE=target/spring-boot-web.jar

# cd /opt/app
WORKDIR /opt/app

# cp target/spring-boot-web.jar /opt/app/app.jar
COPY ${JAR_FILE} app.jar

# java -jar /opt/app/app.jar
ENTRYPOINT ["java","-jar","app.jar"]

5. Dockerize Spring Boot Application

5.1 Go to the folder containing Dockerfile.

$ cd project

$ pwd
/home/mkyong/projects/docker-spring-boot

$ ls -lsah

total 32K
4.0K drwxr-xr-x 5 mkyong mkyong 4.0K Feb  17 20:04 .
4.0K drwxr-xr-x 6 mkyong mkyong 4.0K Feb  14 13:02 ..
4.0K -rw-r--r-- 1 mkyong mkyong  537 Feb  17 20:04 Dockerfile
4.0K -rw-r--r-- 1 mkyong mkyong   80 Feb  14 13:02 docker-spring-boot.iml
4.0K drwxr-xr-x 2 mkyong mkyong 4.0K Feb  17 19:16 .idea
4.0K -rw-r--r-- 1 mkyong mkyong 2.4K Feb  17 18:36 pom.xml
4.0K drwxr-xr-x 4 mkyong mkyong 4.0K Feb  14 13:02 src
4.0K drwxr-xr-x 6 mkyong mkyong 4.0K Feb  17 19:44 target

5.2 sudo docker build -t name:tag .

$ pwd
/home/mkyong/projects/docker-spring-boot

$ sudo docker build -t spring-boot:1.0 .
Sending build context to Docker daemon  19.12MB
Step 1/5 : FROM adoptopenjdk/openjdk11:alpine-jre
 ---> 9aa3eab0cec0
Step 2/5 : ARG JAR_FILE=target/spring-boot-web.jar
 ---> Running in 14b8291509cb
Removing intermediate container 14b8291509cb
 ---> efc9e83cec99
Step 3/5 : WORKDIR /opt/app
 ---> Running in 844380f977af
Removing intermediate container 844380f977af
 ---> 5de2390296cc
Step 4/5 : COPY ${JAR_FILE} app.jar
 ---> d826c8181a83
Step 5/5 : ENTRYPOINT ["java","-jar","app.jar"]
 ---> Running in aa572b8d487b
Removing intermediate container aa572b8d487b
 ---> 468b2f899083
Successfully built 468b2f899083
Successfully tagged spring-boot:1.0

5.3 Start the docker container spring-boot:1.0, run the /opt/app/app.jar file during startup.

• Add run -d to start the container in detach mode – run the container in the background.
• Add run -p to map ports.

$ sudo docker run -d -p 8080:8080 -t spring-boot:1.0

Few more examples to start the container

$ sudo docker run -d -p 80:8080 -t spring-boot:1.0
$ sudo docker run -d -p 443:8443 -t spring-boot:1.0
$ sudo docker run -d -p 80:8080 -p 443:8443 -t spring-boot:1.0

Done, we dockerize a Spring Boot application.

6. FAQs

6.1 List all containers

$ sudo docker ps

CONTAINER ID        IMAGE               COMMAND               CREATED             STATUS              PORTS                    NAMES
3e36a2c0c241        spring-boot:1.0     "java -jar app.jar"   13 seconds ago      Up 12 seconds       0.0.0.0:8080->8080/tcp   elegant_euler

6.2 Stop a container by container id.

$ sudo docker stop 3e36a2c0c241

6.3 How to deploy the container?
The fastest way is to tag and push the image to the official docker hub and pull the container back to the server.

Build an image ‘name:tag’.

$ cd project
$ sudo docker build -t spring-boot:1.0 .

Tag first before push to docker hub.

$ sudo docker image tag spring-boot:1.0 your_id/spring-boot:1.0
$ sudo docker image push your_id/spring-boot:1.0
``

In production server.
```bash
$ sudo docker pull your_id/spring-boot:1.0
$ sudo docker run -d -p 80:8080 -t spring-boot:1.0

6.4 For SSL, declared the certificate (jks or p12) in the application.properties, start at port 8443 (configurable)

# SSL
server.port=8443
server.ssl.key-store=cert.p12
server.ssl.key-store-password=123
server.ssl.keyStoreType=PKCS12

Starts the docker container and maps https 433 to 8443.

$ docker run -d -p 443:8443 -t spring-boot:1.0

Download Source Code

References

• Docker Hub
• Dockerfile reference
• docker build
• Maven tutorials
• Improved Docker Container Integration with Java 10
• docker Java application example

62-docker-compose 结合 dockerfile 部署 springboot 应用

dockerfile 内容：

# 基础镜像
FROM  openjdk:8-jre
# author
MAINTAINER lw

# 挂载目录
VOLUME /home/ybss
# 创建目录
RUN mkdir -p /home/ybss
# 指定路径
WORKDIR /home/ybss

ADD ./jar/lib /home/ybss/lib
ADD ./jar/*.yml /home/ybss/
# 复制jar文件到路径
COPY ./jar/run.jar /home/ybss/run.jar
# 启动认证服务
ENTRYPOINT ["java","-jar","-Dserver.port=9200","-Dspring.profiles.active=dev","run.jar"]

docker-compose.yml 内容：

version : ''3.8''
services:
  ybss-auth:
    container_name: ybss-auth
    build:
      context: ./ybss/auth
      dockerfile: dockerfile
    ports:
      - "19200:9200"
    volumes:
      - /home/ybss/ybss/auth/jar:/home/ybss

networks:
  ybss_default:
    driver: bridge

volumes 挂载目录 /home/ybss/ybss/auth/jar，有更新时，只需要把更新 jar 和文件替换即可。

部署脚本 shell:

#!/bin/sh
auth(){
  chmod 777 -R ./ybss/auth/*
  docker-compose up -d ybss-auth
}
stop(){
	docker-compose stop
}
case "$1" in
"auth")
	auth
;;
"s")
	stop
;;

62-docker-compose 结合dockerfile 部署springboot应用

dockerfile内容：

# 基础镜像
FROM  openjdk:8-jre
# author
MAINTAINER lw

# 挂载目录
VOLUME /home/ybss
# 创建目录
RUN mkdir -p /home/ybss
# 指定路径
WORKDIR /home/ybss

ADD ./jar/lib /home/ybss/lib
ADD ./jar/*.yml /home/ybss/
# 复制jar文件到路径
COPY ./jar/run.jar /home/ybss/run.jar
# 启动认证服务
ENTRYPOINT ["java","-jar","-Dserver.port=9200","-Dspring.profiles.active=dev","run.jar"]

docker-compose.yml 内容：

version : ''3.8''
services:
  ybss-auth:
    container_name: ybss-auth
    build:
      context: ./ybss/auth
      dockerfile: dockerfile
    ports:
      - "19200:9200"
    volumes:
      - /home/ybss/ybss/auth/jar:/home/ybss

networks:
  ybss_default:
    driver: bridge

volumes挂载目录/home/ybss/ybss/auth/jar，有更新时，只需要把更新jar和文件替换即可。

部署脚本shell:

#!/bin/sh
auth(){
  chmod 777 -R ./ybss/auth/*
  docker-compose up -d ybss-auth
}
stop(){
    docker-compose stop
}
case "$1" in
"auth")
    auth
;;
"s")
    stop
;;

docker - dockerfile构建一个简单的springboot应用镜像

      在前面的 《docker - 构建一个简单的docker镜像》中，介绍了两种构建镜像的方法，其中，通过dockerfile文件构建镜像是在实际生产中常用的；除此之外，还通过 docker - Dockerfile常用指令 和  docker - 常用命令 两篇文章介绍了dockerfile的指令和docker的常用命令，接下来，我们将会使用所学的知识构建一个简单的springboot应用。

    该springboot应用对外暴露了一个api，对外暴露8080端口，日志文件写在应用当前目录，部分代码以及配置文件如下：

@Slf4j
@SpringBootApplication
@RestController
public class SpringbootDockerApplication {

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

    @RequestMapping("/docker")
    public String docker() {
        log.info("access docker home at " + LocalTime.now());
        return "Hello Docker!";
    }
}

application.properties

spring.application.name=springboot-docker
server.port=8080
logging.file=app.log

把jar和dockerfile文件上传到一个springboot-docker目录中

[root@localhost springboot-docker]# ls
Dockerfile  springboot-docker-1.0.jar

Dockerfile：

FROM openjdk:8u181-jdk-alpine
ARG workdir=/app
VOLUME ${workdir}
WORKDIR ${workdir}
ADD springboot-docker-1.0.jar app.jar
EXPOSE 8080
ENTRYPOINT ["java","-Djava.security.egd=file:/dev/./urandom","-jar","app.jar"]

• FROM openjdk:8u181-jdk-alpine ： 从docker仓库中获取基础镜像
• ARG workdir=/app ： 添加变量，该变量只在当前的dockerfile中有效，如果换成ENV，则在容器中生效。这里需要注意的是，ARG和ENV对哪些指令是起效的，可以参考  docker - Dockerfile常用指令 
• VOLUME ${workdir} ： 把宿主机的目录（该目录可以通过docker inspect dockerName查看）挂载到容器中的/app这个目录，这样可以在宿主机中查看该目录的内容。还有一个很重要的原因，就是数据持久化，如果不挂载，当容器关闭删除后，数据将会跟着被删除。这里因为/app是应用所在的目录，该目录会产生日志等其它内容。
• WORKDIR ${workdir} ：指定工作目录，下面的指令操作将在这个指定目录中执行。还有一点是，当通过交互模式的exec命令进入到该容器时，默认当前路径是/app
• ADD springboot-docker-1.0.jar app.jar ： 添加文件到WORKDIR
• EXPOSE 8080 ： 暴露8080端口，需要通过容器IP和端口访问应用。如果想通过宿主机的IP和端口访问应用，需要在RUN容器的时候绑定。可以参考docker - Dockerfile常用指令 的run命令
• ENTRYPOINT： 运行容器后执行的第一条命令，这里通过java -jar命令运行应用。

接下通过BUILD命令构建镜像

[root@localhost springboot-docker]# docker build -t springboot-docker:1.0 .

Sending build context to Docker daemon  17.85MB
Step 1/7 : FROM openjdk:8u181-jdk-alpine
 ---> 97bc1352afde
Step 2/7 : ARG workdir=/app
 ---> Using cache
 ---> a3818e8696c2
Step 3/7 : VOLUME ${workdir}
 ---> Using cache
 ---> e2faefe34aa6
Step 4/7 : WORKDIR ${workdir}
 ---> Using cache
 ---> 144b537c1b57
Step 5/7 : ADD springboot-docker-1.0.jar app.jar
 ---> Using cache
 ---> daca849e1012
Step 6/7 : EXPOSE 8080
 ---> Using cache
 ---> 123da0847dd3
Step 7/7 : ENTRYPOINT ["java","-Djava.security.egd=file:/dev/./urandom","-jar","app.jar"]
 ---> Using cache
 ---> de46a3f96d91
Successfully built de46a3f96d91
Successfully tagged springboot-docker:1.0

查看当前本地仓库的镜像，已经构建springboot-docker:1.0镜像

[root@localhost springboot-docker]# docker images
REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
springboot-docker   1.0                 de46a3f96d91        38 minutes ago      121MB
openjdk             8u181-jdk-alpine    97bc1352afde        5 weeks ago         103MB

运行镜像

docker run -p 8080:8080 -d --name springboot-docker springboot-docker:1.0

通过-p参数，把容器中的8080端口映射到宿主机中的8080端口。--name，给容器起一个名字

可以查看springboot应用的启动情况

docker logs -f springboot-docker 

查看容器的运行情况

docker inspect springboot-docker

只看一些关键的信息

"Mounts": [
            {
                "Type": "volume",
                "Name": "90df5c82f11290eddfc86faead12e4a79649672845b2a816e04f868da76851a3",
                "Source": "/var/lib/docker/volumes/90df5c82f11290eddfc86faead12e4a79649672845b2a816e04f868da76851a3/_data",
                "Destination": "/app",
                "Driver": "local",
            }
        ],
"Networks": {
	"bridge": {
		"Gateway": "172.17.0.1",
		"IPAddress": "172.17.0.2",
	}
}

    宿主机中的 /var/lib/docker/volumes/90df5c82f11290eddfc86faead12e4a79649672845b2a816e04f868da76851a3/_data 目录挂载到 容器的 /app目录

    容器的IP地址 172.17.0.2

    运行成功后，在宿主机中通过命令访问服务

curl 172.17.0.2:8080/docker

    也可以通过宿主机的IP或者localhost访问，因为已经绑定

curl 127.0.0.1:8080/docker

Docker Spring boot 项目使用 docker-maven-plugin 执行mvn docker:build 打成镜像

创建Dockerfile文件

此处的参数说明:

FROM openjdk:8-jdk-alpine  基与jdk1.8

VOLUME /tmp   挂载容器的位置, 容易找到

ADD kitty-generator-1.0.0.jar app.jar   宿主机器的jar文件 移动到 容器的jar文件

ENTRYPOINT ["java","-Djava.security.egd=file:/dev/./urandom","-jar","/app.jar"]  容器执行的命令

EXPOSE 9000 简易爆漏的端口 下面docker run -p  还是要的, 因为容器是桥接模式
EXPOSE 9092 写多个就会暴露多个端口

若要执行调优内存:加参数如下

2：POM.xml配置 加入docker:build插件

 <artifactId>kitty-generator</artifactId>  此处和下面${project.artifactId} 对应
 <version>${project.version}</version>
 <packaging>jar</packaging>   此处改为jar包方式

<properties>

*****
   <docker.image.prefix>kitty</docker.image.prefix> 此处和下面${docker.image.prefix} 对应
</properties>

#下面为jar方式.
　　　　<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>
        </plugins>

在父模块打包

mvn clean install package -Dmaven.test.skip

在子模块执行生成镜像

mvn docker:build -Dmaven.test.skip

启动镜像

docker run -itd -p 9000:9000 -v /data/generator/:/data kitty/kitty-generator

 -it  可以交互进入容器

-d   后台运行

-p 端口映射，若项目有多个端口,  -p 9000:9000 -p 9092:9092 写多个即可

-v 挂载文件 宿主/data/generator/ 不存在会自动创建   容器/data会自动创建

挂载文件配置 

   * 注意下方/data/ 红色字体

-v /data/generator/:/data  这的/data 表示容器的日志 将会在宿主机器生成/data/generator/kitty-generator.log文件

<?xml version="1.0" encoding="UTF-8"?>
<configuration>
    <!-- ch.qos.logback.core.ConsoleAppender 控制台输出 -->
    <appender name="console" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>[%-5level] %d{HH:mm:ss.SSS} [%thread] %logger{36} - %msg%n</pattern>
        </encoder>
    </appender>
    <!-- ch.qos.logback.core.rolling.RollingFileAppender 文件日志输出 -->
    <appender name="baselog" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <File>/data/kitty-generator.log</File>
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <fileNamePattern>log/base.%d.%i.log</fileNamePattern>
            <timeBasedFileNamingAndTriggeringPolicy  class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                <maxFileSize>100 MB</maxFileSize>
            </timeBasedFileNamingAndTriggeringPolicy>
        </rollingPolicy>
        <encoder>
            <pattern>
                [%-5level] %d{HH:mm:ss.SSS} [%thread] %logger{36} - %msg%n
            </pattern>
            <charset>UTF-8</charset> <!-- 此处设置字符集 -->
        </encoder>
    </appender>
    <!-- 日志级别 -->
    <root>
        <!-- 定义了ERROR和INFO级别的日志;分别在FILE文件和控制台输出 -->
        <level value="INFO" />
        <appender-ref ref="baselog" />
        <appender-ref ref="console" />
    </root>
    <logger name="com.louis.kitty.generator" level="INFO">
        <appender-ref ref="baselog" />
    </logger>
</configuration>

我们今天的关于Docker + Spring Boot examples的分享已经告一段落，感谢您的关注，如果您想了解更多关于62-docker-compose 结合 dockerfile 部署 springboot 应用、62-docker-compose 结合dockerfile 部署springboot应用、docker - dockerfile构建一个简单的springboot应用镜像、Docker Spring boot 项目使用 docker-maven-plugin 执行mvn docker:build 打成镜像的相关信息，请在本站查询。