用 Docker、Gradle 来构建、运行、发布一个 Spring Boot 应用 - 推酷
用 Docker、Gradle 来构建、运行、发布一个 Spring Boot 应用
本文演示了如何用 Docker、Gradle 来构建、运行、发布来一个 Spring Boot 应用。
Docker 简介
是一个 Linux 容器管理工具包，具备“社交”方面，允许用户发布容器的 image (镜像)，并使用别人发布的 image。Docker image 是用于运行容器化进程的方案，在本文中，我们将构建一个简单的 Spring Boot 应用程序。
有关 Docker 的详细介绍，可以移步至《简述 Docker》
Docker 最新版。有关 Docker 在的安装，可以参阅
。 如果你的电脑不是 Linux 系统，最好装个虚拟机，在虚拟机里面装个 Linux ，因为 Docker 的依赖 Linux。
用 Gradle 构建项目
创建目录结构
项目的目录结构因符合 Gradle 的约定。
在 *nix 系统下执行
mkdir -p src/main/java/docker_spring_boot
,生产如下结构 :
└── src
└── main
└── java
└── com
└── waylau
└── docker_spring_boot
创建 Gradle 构建文件
build.gradle
buildscript {
repositories {
mavenCentral()
dependencies {
classpath('org.springframework.boot:spring-boot-gradle-plugin:1.3.3.RELEASE')
// tag::build[]
classpath('se.transmode.gradle:gradle-docker:1.2')
// end::build[]
apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'idea'
apply plugin: 'spring-boot'
// tag::plugin[]
apply plugin: 'docker'
// end::plugin[]
// This is used as the docker image prefix (org)
group = 'gregturn'
baseName = 'docker-spring-boot-gradle'
// tag::task[]
task buildDocker(type: Docker, dependsOn: build) {
push = true
applicationName = jar.baseName
dockerfile = file('src/main/docker/Dockerfile')
into stageDir
// end::task[]
repositories {
mavenCentral()
sourceCompatibility = 1.8
targetCompatibility = 1.8
dependencies {
compile(&org.springframework.boot:spring-boot-starter-web&)
testCompile(&org.springframework.boot:spring-boot-starter-test&)
task wrapper(type: Wrapper) {
gradleVersion = '2.3'
提供了很多方便的功能：
它收集的类路径上所有 jar 文件，并构建成一个单一的、可运行的“&ber-jar”（德语，相关解释可以移步至
），这使得它更方便地执行和传输服务。
编写 Spring Boot 应用
编写一个简单的 Spring Boot 应用 ：
src/main/java/com/waylau/docker_spring_boot/Application.java
package com.waylau.docker_spring_
import org.springframework.boot.SpringA
import org.springframework.boot.autoconfigure.SpringBootA
import org.springframework.web.bind.annotation.RequestM
import org.springframework.web.bind.annotation.RestC
* 主应用入口
* @author &a href=&&&&/a&
* @date 日
@SpringBootApplication
@RestController
public class Application {
@RequestMapping(&/&)
public String home() {
return &Hello Docker World.&
+ &&br /&Welcome to &a href=''&&/a&&/li&&;
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
解释下上面的代码：
@SpringBootApplication
@RestController
标识,可用 Spring MVC 来处理 Web 请求。
@RequestMapping
，并将&Hello Docker World& 文本作为响应。
方法使用 Spring Boot 的
SpringApplication.run()
方法来启动应用。
使用 Gradle
gradle build
java -jar build/libs/docker-spring-boot-gradle-1.0.0.jar
如果程序正确运行，浏览器访问
，可以看到页面 “Hello Docker World.” 字样。
将项目容器化
Docker 使用
文件格式来指定 image 层，
src/main/docker/Dockerfile
FROM frolvlad/alpine-oraclejdk8:slim
VOLUME /tmp
ADD docker-spring-boot-gradle-1.0.0.jar app.jar
ENTRYPOINT [&java&,&-Djava.security.egd=file:/dev/./urandom&,&-jar&,&/app.jar&]
解释下这个配置文件：
指定了临时文件目录为
。其效果是在主机
/var/lib/docker
目录下创建了一个临时文件，并链接到容器的
。改步骤是可选的，如果涉及到文件系统的应用就很有必要了。
目录用来持久化到 Docker 数据文件夹，因为 Spring Boot 使用的内嵌 Tomcat 容器默认使用
作为工作目录
项目的 jar 文件作为 &app.jar& 添加到容器的
ENTRYPOINT
执行项目 app.jar。为了缩短
，添加一个系统属性指向 &/dev/urandom& 作为 Entropy Source
构建 Docker Image
执行构建成为 docker image:
gradle build buildDocker
运行 Docker Image
docker run -p
-t waylau/docker-spring-boot-gradle
[root@waylau spring-boot]# docker run -p
-t waylau/docker-spring-boot-gradle
/\\ / ___'_ __ _ _(_)_ __
__ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
___)| |_)| | | | | || (_| |
|____| .__|_| |_|_| |_\__, | / / / /
=========|_|==============|___/=/_/_/_/
:: Spring Boot ::
(v1.3.3.RELEASE)
08:45:51.276
INFO 1 --- [
main] c.waylau.docker_spring_boot.Application
: Starting Application v1.0.0 on 048fb623038f with PID 1 (/app.jar started by root in /)
08:45:51.289
INFO 1 --- [
main] c.waylau.docker_spring_boot.Application
: No active profile set, falling back to default profiles: default
08:45:51.722
INFO 1 --- [
main] ationConfigEmbeddedWebApplicationContext : Refreshing org.springframework.boot.context.embedded.AnnotationConfigEmbeddedWebApplicationContext@669af5fc: startup date [Sun Mar 20 08:45:51 GMT 2016]; root of context hierarchy
08:45:54.874
INFO 1 --- [
main] o.s.b.f.s.DefaultListableBeanFactory
: Overriding bean definition for bean 'beanNameViewResolver' with a different definition: replacing [Root bean: class [null]; scope=; abstract= lazyInit= autowireMode=3; dependencyCheck=0; autowireCandidate= primary= factoryBeanName=org.springframework.boot.autoconfigure.web.ErrorMvcAutoConfiguration$WhitelabelErrorViewC factoryMethodName=beanNameViewR initMethodName= destroyMethodName=(inferred); defined in class path resource [org/springframework/boot/autoconfigure/web/ErrorMvcAutoConfiguration$WhitelabelErrorViewConfiguration.class]] with [Root bean: class [null]; scope=; abstract= lazyInit= autowireMode=3; dependencyCheck=0; autowireCandidate= primary= factoryBeanName=org.springframework.boot.autoconfigure.web.WebMvcAutoConfiguration$WebMvcAutoConfigurationA factoryMethodName=beanNameViewR initMethodName= destroyMethodName=(inferred); defined in class path resource [org/springframework/boot/autoconfigure/web/WebMvcAutoConfiguration$WebMvcAutoConfigurationAdapter.class]]
08:45:57.893
INFO 1 --- [
main] s.b.c.e.t.TomcatEmbeddedServletContainer : Tomcat initialized with port(s): 8080 (http)
08:45:57.982
INFO 1 --- [
main] o.apache.catalina.core.StandardService
: Starting service Tomcat
08:45:57.984
INFO 1 --- [
main] org.apache.catalina.core.StandardEngine
: Starting Servlet Engine: Apache Tomcat/8.0.32
08:45:58.473
INFO 1 --- [ost-startStop-1] o.a.c.c.C.[Tomcat].[localhost].[/]
: Initializing Spring embedded WebApplicationContext
08:45:58.473
INFO 1 --- [ost-startStop-1] o.s.web.context.ContextLoader
: Root WebApplicationContext: initialization completed in 6877 ms
08:45:59.672
INFO 1 --- [ost-startStop-1] o.s.b.c.e.ServletRegistrationBean
: Mapping servlet: 'dispatcherServlet' to [/]
08:45:59.695
INFO 1 --- [ost-startStop-1] o.s.b.c.embedded.FilterRegistrationBean
: Mapping filter: 'characterEncodingFilter' to: [/*]
08:45:59.701
INFO 1 --- [ost-startStop-1] o.s.b.c.embedded.FilterRegistrationBean
: Mapping filter: 'hiddenHttpMethodFilter' to: [/*]
08:45:59.703
INFO 1 --- [ost-startStop-1] o.s.b.c.embedded.FilterRegistrationBean
: Mapping filter: 'httpPutFormContentFilter' to: [/*]
08:45:59.703
INFO 1 --- [ost-startStop-1] o.s.b.c.embedded.FilterRegistrationBean
: Mapping filter: 'requestContextFilter' to: [/*]
08:46:00.862
INFO 1 --- [
main] s.w.s.m.m.a.RequestMappingHandlerAdapter : Looking for @ControllerAdvice: org.springframework.boot.context.embedded.AnnotationConfigEmbeddedWebApplicationContext@669af5fc: startup date [Sun Mar 20 08:45:51 GMT 2016]; root of context hierarchy
08:46:01.166
INFO 1 --- [
main] s.w.s.m.m.a.RequestMappingHandlerMapping : Mapped &{[/]}& onto public java.lang.String com.waylau.docker_spring_boot.Application.home()
08:46:01.189
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)
08:46:01.190
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)
08:46:01.302
INFO 1 --- [
main] o.s.w.s.handler.SimpleUrlHandlerMapping
: Mapped URL path [/webjars/**] onto handler of type [class org.springframework.web.servlet.resource.ResourceHttpRequestHandler]
08:46:01.302
INFO 1 --- [
main] o.s.w.s.handler.SimpleUrlHandlerMapping
: Mapped URL path [/**] onto handler of type [class org.springframework.web.servlet.resource.ResourceHttpRequestHandler]
08:46:01.438
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]
08:46:01.833
INFO 1 --- [
main] o.s.j.e.a.AnnotationMBeanExporter
: Registering beans for JMX exposure on startup
08:46:02.332
INFO 1 --- [
main] s.b.c.e.t.TomcatEmbeddedServletContainer : Tomcat started on port(s): 8080 (http)
08:46:02.343
INFO 1 --- [
main] c.waylau.docker_spring_boot.Application
: Started Application in 13.194 seconds (JVM running for 15.828)
如果程序正确运行，浏览器访问
，可以看到页面 “Hello Docker World.” 字样。
推送 image 到 Docker Hub
首先，你在 Docker Hub 要有注册账号，且创建了相应的库；
其次，docker 推送前，先要登录，否则报
unauthorized: access to the requested resource is not authorized
docker login
[root@waylau spring-boot]# docker login
Username: waylau
WARNING: login credentials saved in /root/.docker/config.json
Login Succeeded
docker push waylau/docker-spring-boot-gradle
[root@waylau spring-boot]# docker push waylau/docker-spring-boot-gradle
The push refers to a repository [docker.io/waylau/docker-spring-boot-gradle]
751d29eef02e: Layer already exists
4da: Pushed
5f70bf18a086: Layer already exists
7e4d0cb13643: Layer already exists
8ff: Layer already exists
latest: digest: sha256:eb4d489d84bda98d746abba59b35164 size: 9415
镜像加速器
Docker Hub 在国外，有时候拉取 Image 极其缓慢，可以使用国内的镜像来实现加速
echo &DOCKER_OPTS=\&--registry-mirror=https://yourlocation.\&& | sudo tee -a /etc/default/docker
sudo service docker restart
是您在阿里云注册后的专属加速器地址：
sudo echo “DOCKER_OPTS=\”\$DOCKER_OPTS –registry-mirror=http://your-id.m.daocloud.io -d\”” && /etc/default/docker
sudo service docker restart
是您在 DaoCloud 注册后的专属加速器地址：
获取项目源码，
samples/spring-boot-gradle
获取项目镜像， 执行
docker pull waylau/docker-spring-boot-gradle
已发表评论数()
请填写推刊名
描述不能大于100个字符!
权限设置： 公开
仅自己可见
正文不准确
标题不准确
排版有问题
主题不准确
没有分页内容
图片无法显示
视频无法显示
与原文不一致点击阅读原文
Docker多步构建更小的Java镜像
5月2日 发布，来源：
译者按: 最新版Docker将支持多步构建(Multi-stage build)，这样使用单个Dockerfile就可以定义多个中间镜像用于构建，测试以及发布等多个步骤，并且有效减小最终镜像的大小。
为了保证可读性，本文采用意译而非直译。
Github仓库:
中与Java开发者直接相关的内容有:
Docker多步构建(Docker Multi-stage build)
这篇博客介绍了为什么需要Docker多步构建(Docker Multi-stage build)，并且通过一个示例展示了如何构建更小的Java镜像。
为什么需要多步构建?
为Java应用构建Docker镜像意味着编译源代码以及打包目标代码。开发者通常会使用Maven或者Gradle来构建JAR或WAR文件。若使用Maven镜像作为基础镜像来构建Java应用，则需要下载所有Maven依赖。下载的JAR包数目由pm.xml决定，有可能会非常多。这样的话，生成的Docker镜像中将留下太多多余的文件。
下面为示例Dockerfile:
FROM maven:3.5-jdk-8
COPY src /usr/src/myapp/src
COPY pom.xml /usr/src/myapp
RUN mvn -f /usr/src/myapp/pom.xml clean package
ENV WILDFLY_VERSION 10.1.0.Final
ENV WILDFLY_HOME /usr
RUN cd $WILDFLY_HOME && curl http://download.jboss.org/wildfly/$WILDFLY_VERSION/wildfly-$WILDFLY_VERSION.tar.gz | tar zx && mv $WILDFLY_HOME/wildfly-$WILDFLY_VERSION $WILDFLY_HOME/wildfly
RUN cp /usr/src/myapp/target/people-1.0-SNAPSHOT.war $WILDFLY_HOME/wildfly/standalone/deployments/people.war
EXPOSE 8080
CMD ["/usr/wildfly/bin/standalone.sh", "-b", "0.0.0.0"]
由Dockerfile可知:
maven:3.5-jdk-8 是基础镜像
将源代码拷贝到镜像中
Maven用于构建应用
下载并安装WildFly
将生成的.war文件拷贝到WildFly的deployments目录
启动WildFly
这个Dockefile存在这些问题：
使用Maven作为基础镜像的话，还需要安装和配置WildFly。
构建应用时需要下载很多Maven依赖，它们会继续留在镜像中，但是运行应用时并不需要它们。这导致了镜像过大。
修改WildFly版本则需要修改Dockerfile，并重新构建镜像。如果直接使用WildFly镜像作为基础镜像，情况会简单很多。
打包应用之前，需要进行单元测试，那么，测试的依赖也需要留在生成的镜像中，这其实是没必要的。
当然，也可以采用其他方式构建Docker镜像。比如，可以将Dockerfile拆分为两个。第一个Dockerfile以Maven镜像为基础镜像，用于构建应用，并将构建好的.war文件通过数据卷(volume)复制到共享的目录；第二个Dockerfile以WildFly镜像作为基础镜像，从数据卷将.war文件拷贝出来就好了。这个方法也是有问题的，因为需要维护多个Dockerfile，并且通过数据卷拷贝文件也不方便。
什么是Docker多步构建？
多步构建(multi-stage build)允许在Dockerfile中使用多个FROM指令。两个FROM指令之间的所有指令会生产一个中间镜像，最后一个FROM指令之后的指令将生成最终镜像。中间镜像中的文件可以通过COPY --from=&image-number&指令拷贝，其中image-number为镜像编号，0为第一个基础镜像。没有被拷贝的文件都不会存在于最终生成的镜像，这样可以减小镜像大小。
FROM指令可以使用as &stage-name&来指定步骤名称(stage name):
FROM maven:3.5-jdk-8 as BUILD这样的话，COPY指令的--from选项可以使用步骤名称代替镜像编号。
下面为示例Dockerfile:
FROM maven:3.5-jdk-8 as BUILD
COPY src /usr/src/myapp/src
COPY pom.xml /usr/src/myapp
RUN mvn -f /usr/src/myapp/pom.xml clean package
FROM jboss/wildfly:10.1.0.Final
COPY --from=BUILD /usr/src/myapp/target/people-1.0-SNAPSHOT.war /opt/jboss/wildfly/standalone/deployments/people.war
由Dockerfile可知:
一共有两个FROM指令，因此为两步构建。
maven:3.5-jdk-8 是第一步构建的基础镜像。这一步用于构建应用的WAR文件。这一步的名称为build。
jboss/wildfly:10.1.0.Final 是第二步构建的基础镜像。第一步构建的WAR文件通过COPY --from指令拷贝到WildFly的deloyments目录。
Docker多步构建有什么好处？
仅需要一个Dockerfile来定义整个构建过程。这样，不需要定义多个Dockerfile，也不需要使用数据卷来拷贝文件。
可以为最终镜像选择合适的基础镜像，来满足生产环境的需求，这样可以有效减小最终镜像的大小。另外，构建步骤的多余文件都被丢弃了。
使用官方的WildFly镜像作为生产镜像的基础镜像，而不是手动安装和配置WildFly。这样，WildFly升级时将非常方便。
注：Docker多步构建正在开发中，还没有正式发布。可以通过 curl -fsSL / | sh命令安装最新的测试版Docker试用多步构建。
使用第一个Dockerfile构建的镜像为816MB，而使用多步构建的话，镜像只有584MB。
docker-java-multistage $ docker imagesREPOSITORY TAG IMAGE ID CREATED SIZEpeople multistage d36a4b82ad87 59 seconds ago 584MBpeople singlestage 13dbcf8f54f6 5 minutes ago 816MB可知，使用多步构建可以有效减小镜像大小。
查看，有更加详细的讨论。
欢迎加入的Docker技术交流群: 。
转载时请注明作者以及本文地址：
您的用户遇到Bug了吗？
明天提醒我
我要该，理由是：
关闭理由：
删除理由：
忽略理由：
推广（招聘、广告、SEO 等）方面的内容
与已有问题重复（请编辑该提问指向已有相同问题）
答非所问，不符合答题要求
宜作评论而非答案
带有人身攻击、辱骂、仇恨等违反条款的内容
无法获得确切结果的问题
非开发直接相关的问题
非技术提问的讨论型问题
其他原因（请补充说明）
扫扫下载 App使用gradle生成Spring Boot应用的Docker Image -解道Jdon
& & & &&& & &
本教程演示如何通过gradle将一个Spring Boot应用生成Docker的Image，Docker的Image类似Java的WAR发布包，可以被Docker容器带着在任何操作系统上运行，一个操作系统也可以运行多个Docker容器。
本案例源码 .
首先，基于Spring boot的应用很简单，通过浏览器输出Hello World，代码如下：
@RestController
@Configuration
@EnableAutoConfiguration
@ComponentScan
public class Application {
public static void main(String[] args) {
ApplicationContext ctx = SpringApplication.run(Application.class, args);
@RequestMapping(&/&)
public String index() {
return &Hello to you, world&;
这是访问URL根目录/会返回Hello的应用，application.properties配置如下：
server.port: 8080
下面是使用gradle来配置这个应用，以便生成Docker的Imag. 四个步骤：
1. 加入gradle插件
为了Docker-ize 应用，需要两个插件docker 和 application. gradle有两个docker插件开源项目：和及 。
将插件加入配置文件build.gradle
apply plugin: 'application'
apply plugin: 'docker'
需要在dependencies 配置告诉gradle如何发现这些插件。
为Docker插件指定classpath:
buildscript {
repositories { mavenCentral() }
dependencies {
classpath 'se.transmode.gradle:gradle-docker:1.1'
2.提供一些属性
gradle-docker插件只是创建一个Dockerfile文件，然后供docker命令行来建立一个image. 因此，你需要在 build.gradle提供一些属性，以便能有效自动运行你的应用。
运行的类，也就是包含main方法的应用类
JVM 版本 (缺省是 Java 7)
, 一个group id, 适合于 Docker 归类的标签.
group = 'aglover'
sourceCompatibility = 1.7
mainClassName = 'com.github.aglover.galoshe.Application'
虽然group不是必须的，可以帮助Docker归类贴上标签，当插件创建一个Docker image时,它会使用 group/name 方式给这个image命名。
最后，启动的主类名是启动应用的入口，F插件会创建一个脚本，这样你的Docker image在启动时会调用这个脚本，脚本类似如下格式:
java -classpath your_class_path your_main_class
3.指定Dockerfile所需
Dockerfiles 包含一些有关image相应的指令要求，，这里的Spring Boot应用只需要一个参数：端口，可以通过插件的exposePort方法设置。
因此，为确保Docker容器能 按照之前定义的application.properites文件暴露端口8080,加入下面脚本到build.gradle 文件：
指定端口 8080
distDocker {
exposePort 8080
依次可以想象，在插件中加入addFile实际是Docker的ADD指令，而runCommand会对应aRUN，而setEnvironment会创建一个ENV指令。
4.构建运行
最后一步我们运行gradle来创建Docker Image，如下：
$ ./gradlew distDocker
当你第一次运行这个命令，它会下载一些所需的Image。构建完成后，你可以查询列出本地的image.文件：
$ docker images
REPOSITORY
VIRTUAL SIZE
aglover/galoshe
332e163221bc
20 hours ago
dockerfile/java
3 weeks ago
在docker中运行这个Image
docker run 332e163221bc
然后打开浏览器，访问localhost:8080即可
当然你可以 让其他人直接使用。
| 网站地图 | 设为首页