Docker提供了重新启动策略 来控制容器在退出时或Docker重新启动时是否自动启动。重新启动策略可确保以正确的顺序启动链接的容器。Docker建议您使用重新启动策略，并避免使用进程管理器来启动容器。 重新启动策略--live-restore与dockerd 命令的标志不同。--live-restore尽管网络和用户输入中断，但使用允许您在Docker升级期间保持容器运行。 使用重启策略 要为容器配置重新启动策略，请--restart在使用该docker run命令时使用该标志。--restart标志的值可以是以下任何一种： 旗 描述 no 不要自动重启容器。（默认） on-failure 如果容器由于错误而退出，则重新启动容器，该错误表现为非零退出代码。 always 如果容器停止，请务必重启容器。如果手动停止，则仅在Docker守护程序重新启动或手动重新启动容器本身时才重新启动。（参见重启政策详情中列出的第二个项目） unless-stopped 类似于always，除了当容器停止（手动或其他方式）时，即使在Docker守护程序重新启动后也不会重新启动容器。 以下示例启动Redis容器并将其配置为始终重新启动，除非明确停止或重新启动Docker。
|
1 |
$ docker run -dit --restart unless-stopped redis |
重启政策详情 使用重启策略时请记住以下几点： 重启策略仅在容器成功启动后生效。在这种情况下，成功启动意味着容器启动至少10秒并且Docker已开始监视它。这可以防止根本不启动的容器进入重启循环。 如果手动停止容器，则会忽略其重新启动策略，直到Docker守护程序重新启动或手动重新启动容器。这是防止重启循环的另一种尝试。 重新启动策略仅适用于容器。群组服务的重新启动策略配置不同。请参阅与服务重新启动相关的 标志。 如果run时没有添加restart 可以通过update命令追加 docker update --restart=always web 1、先后台启动容器未加restart参数 2、docker ps 查看了当前运行的容器 3、重启docker 服务 4、再次docker ps 查看当前运行的容器，发现容器并没有运行 5、利用 update 设置 restart=always 6、重启docker 服务 7、再次docker ps 查看当前运行的容器，此时发现已经自动启动容器 ——————— 使用流程管理器 如果重新启动策略不适合您的需要，例如当Docker之外的进程依赖Docker容器时，您可以使用流程管理器，例如 upstart， systemd或supervisor。 警告：不要尝试将Docker重新启动策略与主机级进程管理器结合使用，因为这会产生冲突。 要使用进程管理器，请将其配置为使用您通常用于手动启动容器的相同docker start或docker service命令来启动容器或服务。有关更多详细信息，请参阅特定流程管理器的文档。 在容器内使用进程管理器 进程管理器也可以在容器内运行，以检查进程是否正在运行，如果没有则启动/重启进程 官方介绍在此，以上内容引用官网内容 https://docs.docker.com/engine/admin/start-containers-automatically/#use-a-process-manager from:https://www.cnblogs.com/wei9593/p/11192908.html
View Details当docker容器创建后，忘记挂接做本地与容器目录挂接后，导致数据存储都是存在容器中，如果想修改容器内文件或替换，就需要通过以下命令替换。
|
1 |
docker cp [本地目录或文件]: [容器名][容器内目录] |
为了方便，只要在linux目录替换，可以通过容器挂载的方式，只要替换linux的目录，就能实现容器内的文件变更。 挂载目录步骤如下： 1、停止docker运行
|
1 |
systemctl stop docker |
2、修改容器的配制文件 容器路径：/var/lib/docker/containers/[容器ID] 修改的文件： 2.1、hostconfig.json 在"Binds"节点中增加挂载目录的关系，如：
|
1 |
"Binds" ["/opt/docker/test/webapps:/opt/apache-tomcat-8.5.40/webapps"] |
前面的是本地目录，后面的是容器目录，多个的话，用逗号隔开。 2.2、config.v2.json 在"MountPoints" 节点中增加挂载目录。如：
|
1 |
"MountPoints": {"/opt/apache-tomcat-8.5.40/webapps": {"Source": "/opt/docker/test/webapps","Destination": "/opt/apache-tomcat-8.5.40/webapps","RW": true,"Name": "","Driver": "","Type": "bind","Propagation": "rprivate","Spec": {"Type": "bind","Source": "/opt/docker/test/webapps","Target": "/opt/apache-tomcat-8.5.40/webapps"},"SkipMountpointCreation": false}} |
3、重新docker,开启容器
|
1 |
systemctl start dockerdocker start [容器名或容器ID] |
以上是以修改正在运行的容器的方式挂载目录。 还有简单的方式： 提交现有容器为新镜像，然后重新运行挂载。 from:https://blog.csdn.net/weixin_36431535/article/details/113067296
View DetailsDocker容器做端口映射报错 docker: Error response from daemon: driver failed programming external connectivity on endpoint lamp3 (46b7917c940f7358948e55ec2df69a4dec2c6c7071b002bd374e8dbf0d40022c): (iptables failed: iptables --wait -t nat -A DOCKER -p tcp -d 0/0 --dport 86 -j DNAT --to-destination 172.17.0.2:80 ! -i docker0: iptables: No chain/target/match by that name. 解决方法 docker服务启动时定义的自定义链DOCKER被清除 重启即可systemctl restart docker ———————————————— 版权声明：本文为CSDN博主「米粥粥」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。 原文链接：https://blog.csdn.net/qq_41545647/article/details/102679560
View Details用Dockerfile构建jdk镜像的时候出的错 把Dockerfile文件删除之后重新建一个 把空格 符号全更换一遍英文 最后运行成功 from:https://blog.csdn.net/weixin_43555477/article/details/106480089
View Details以我们家庭好医.netcore项目做个示例，来看看怎么进一步优化Docker镜像的大小。 这里以先编译再做镜像的方法为示例，当然你也可以把编译部分也写进Dockerfile里。 0.先来看看编译后的项目文件大小：39.2MB 1.先看一下VS2019默认Dockerfile生成的镜像 先上Dockerfile
|
1 2 3 4 5 6 7 8 |
FROM mcr.microsoft.com/dotnet/aspnet:3.1 AS base WORKDIR /app EXPOSE 5000 FROM base AS final WORKDIR /app COPY . . ENTRYPOINT ["dotnet", "JTHY.Web.dll"] |
看看生成的镜像大小：265MB 2.用大家常用的slim镜像试试 Dockerfile
|
1 2 3 4 5 6 7 8 |
FROM mcr.microsoft.com/dotnet/core/aspnet:3.1-buster-slim AS base WORKDIR /app EXPOSE 5000 FROM base AS final WORKDIR /app COPY /. /app ENTRYPOINT ["dotnet", "JTHY.Web.dll"] |
镜像大小还是265MB，并没有变小。 3.用大家不常用的alpine镜像来优化 Dockerfile
|
1 2 3 4 5 6 7 8 |
ROM mcr.microsoft.com/dotnet/aspnet:3.1-alpine AS base WORKDIR /app EXPOSE 5000 FROM base AS final WORKDIR /app COPY /. /app ENTRYPOINT ["dotnet", "JTHY.Web.dll"] |
再来看看镜像大小：146MB，是不是很神奇~
View Details一:最基本的Dockerfile构建Springboot项目 在pom同目录下新建Dockerfile
|
1 2 3 4 |
FROM openjdk:8-jdk-alpine VOLUME /tmp COPY target/*.jar app.jar ENTRYPOINT ["java","-jar","/app.jar"] |
将Springboot使用Maven打包，在终端中传参进去，进行构建Images。
|
1 2 3 |
docker build --build-arg=target/*.jar -t demo1/app . #构建完成后启动容器 docker run -p 8080:8080 demo1/app |
给Springboot启动时候传环境变量或者shell参数
|
1 2 3 4 5 |
FROM openjdk:8-jdk-alpine VOLUME /tmp ARG JAR_FILE COPY ${JAR_FILE} app.jar ENTRYPOINT ["sh", "-c", "java ${JAVA_OPTS} -jar /app.jar ${0} ${@}"] |
指定JVM参数和shell参数
|
1 |
docker run -p 9000:9000 -e "JAVA_OPTS=-Ddebug -Xmx128m" demo1/app --server.port=9000 |
二：使用Idea可视化管理docker， 构建Springboot容器 这个在我另外一篇文章有讲到，都比较简单，有啥问题请留言。 三：使用Maven插件自动化构建Image https://github.com/spotify/dockerfile-maven ，能力强的可以直接去看README.md。 简单介绍一下这个插件做啥用的 通过pom配置docker构建Image过程，参数等 。 封装了自动化build，push，run等Maven命令 。 * 需要依赖Dockerfile，Dockerfile与pom.xml位于同一个目录下。 在pom.xml同目录下创建Dockerfile
|
1 2 3 4 |
FROM openjdk:8-jre ENTRYPOINT ["/usr/bin/java", "-jar", "/usr/share/myservice/app.jar"] ARG JAR_FILE ADD target/${JAR_FILE} /usr/share/myservice/app.jar |
在pom中添加
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 |
<plugin> <groupId>com.spotify</groupId> <artifactId>dockerfile-maven-plugin</artifactId> <version>1.4.13</version> <executions> <execution> <id>default</id> <goals> <goal>build</goal> <goal>push</goal> </goals> </execution> </executions> <configuration> <!--你需要配置的地方--> <!--指定仓库名/镜像名--> <repository>myrep/${project.artifactId}</repository> <!--指定tag --> <tag>${project.version}</tag> <buildArgs> <!--指定参数jar--> <JAR_FILE>${project.build.finalName}.jar</JAR_FILE> </buildArgs> </configuration> </plugin> |
最后在Idea Maven插件Plugins点击docker:build即可。或者输入命令
|
1 |
mvn com.spotify:dockerfile-maven-plugin:build |
四:使用Google的Maven插件进行容器管理(重头戏) Google开源项目Jib，对比上面那个插件Jib的Start数为7.8k，dockerfile-maven 为2.4k。 maven 插件
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 |
<plugin> <groupId>com.google.cloud.tools</groupId> <artifactId>jib-maven-plugin</artifactId> <version>1.6.0</version> <configuration> <!--配置基本镜像--> <from> <image>openjdk:8-jdk-alpine</image> </from> <!--配置最终推送的地址，仓库名，镜像名--> <to> <image>registry.hub.docker.com/maoduntt/test</image> </to> </configuration> <!--绑定到maven lifecicle--> <executions> <execution> <phase>package</phase> <goals> <goal>build</goal> </goals> </execution> </executions> </plugin> |
配置maven docker hub账户和密码,在maven settings.xml中添加
|
1 2 3 4 5 |
<server> <id>registry.hub.docker.com</id> <username>你的dockerhub用户名</username> <password>你的dockerhub密码</password> </server> |
在idea maven插件中点击或者maven命令 mvn compile jib:buildTar 可以看到推送远程成功，Jib不需要写Dockerfile只需要你在插件中定义构建类型，所以使用时请多参考github的文档。最后现在也有这种开源的容器云平台，可以去了解下。 from:https://zhuanlan.zhihu.com/p/89161347
View Details环境： 1、代码编写工具：IDEA 2、打包：maven 3、docker 4、linux 7、JDK1.8 8、Xshell 9、Xftp 第一步：使用idea创建简单的springboot项目 第二步：设置项目生成jar包(两种方式) 1、修改pom文件
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 |
<?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.example</groupId> <artifactId>ordinary</artifactId> <version>0.0.1-SNAPSHOT</version> <packaging>jar</packaging> <name>ordinary</name> <description>Demo project for Spring Boot</description> <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.0.6.RELEASE</version> <relativePath/> <!-- lookup parent from repository --> </parent> <properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding> <java.version>1.8</java.version> </properties> <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter</artifactId> </dependency> <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> </plugins> </build> </project> |
2、或者在生成项目的时候 可以选择jar和war 第三步：使用maven 生成包 (使用idea不用命令 直接界面操作就可以(如果Maven设置没问题 直接就可以生成 包 log会提示生成后的文件目录)) 第四步：docker概念 1、docker：最早是dotCloud公司出品的一套容器管理工具，但后来Docker慢慢火起来了，连公司名字都从dotCloud改成Docker。 2、dockerfile：它是Docker镜像的描述文件，可以理解成火箭发射的A、B、C、D……的步骤。 3、docker镜像：通过Dockerfile做出来的，包含操作系统基础文件和软件运行环境，它使用分层的存储方式。 4、docker容器：是运行起来的镜像，简单理解，Docker镜像相当于程序，容器相当于进程。 第四步：dockerfile指令 Dockerfile由多条指令组成，每条指令在编译镜像时执行相应的程序完成某些功能，由指令+参数组成，以逗号分隔，#作为注释起始符，虽说指令不区分大小写，但是一般指令使用大些，参数使用小写 第五步：dockerfile文件例子(我只是简单将springboot项目生成docker镜像没有什么多余配置) TODO：有一点需要注意的地方就是dockerfile文件没有任何后缀
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
# Pull base image FROM java:8 MAINTAINER yihj "yihj@yinghaikeji.com" VOLUME /tmp # 添加 ADD ordinary.jar app.jar RUN bash -c 'touch /app.jar' # Define default command. ENTRYPOINT ["java","-Dspring.profiles.active=online","-Djava.security.egd=file:/dev/./urandom","-jar","/app.jar"] #设置时区 RUN /bin/cp /usr/share/zoneinfo/Asia/Shanghai /etc/localtime && echo 'Asia/Shanghai' >/etc/timezone |
第六步：将dockerfile文件和生成好的jar 使用ftp工具上传到linux服务器 随便找个文件夹 放进去 jar和dockerfile在同级目录下 第七步：使用 docker build -t ordinary:v1.0 . TODO： 1、 最后面的这个 . 代表在当前目录下面寻找 dockerfile 文件 2、ordinary 镜像名字 3、v1.0版本 第八步：查看镜像及启动 1、使用docker images 来查看生成的镜像 2、使用docker create 来创建容器 docker run 来创建并且运行容器 3、也可以使用docker logs 容器名 --tail 100 -f 来查看项目启动日志 看项目是否启动 3、如果上面步骤一切正常 可以直接调用IP加端口来访问项目 通过Docker run命令定义Spring Profile 可以将spring profile作为环境变量传递给docker run命令，使用 -e 标记。 例如 -e “SPRING_PROFILES_ACTIVE=dev”会将dev profile传递给Docker容器 docker run -d -p 8080:8080 -e "SPRING_PROFILES_ACTIVE=dev" […]
View Details1.创建springboot项目 创建springboot项目
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
package com.eangulee.demo.controller; import org.springframework.stereotype.Controller; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.ResponseBody; @Controller public class HelloController { @RequestMapping("/") @ResponseBody public String hello() { return "Hello, SpringBoot With Docker"; } } |
2.打包springboot项目为jar包 3. 编写Dockerfile文件
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
# Docker image for springboot file run # VERSION 0.0.1 # Author: eangulee # 基础镜像使用java FROM java:8 # 作者 MAINTAINER eangulee <eangulee@gmail.com> # VOLUME 指定了临时文件目录为/tmp。 # 其效果是在主机 /var/lib/docker 目录下创建了一个临时文件，并链接到容器的/tmp VOLUME /tmp # 将jar包添加到容器中并更名为app.jar ADD demo-0.0.1-SNAPSHOT.jar app.jar # 运行jar包 RUN bash -c 'touch /app.jar' ENTRYPOINT ["java","-Djava.security.egd=file:/dev/./urandom","-jar","/app.jar"] |
解释下这个配置文件： VOLUME 指定了临时文件目录为/tmp。其效果是在主机 /var/lib/docker 目录下创建了一个临时文件，并链接到容器的/tmp。该步骤是可选的，如果涉及到文件系统的应用就很有必要了。/tmp目录用来持久化到 Docker 数据文件夹，因为 Spring Boot 使用的内嵌 Tomcat 容器默认使用/tmp作为工作目录 项目的 jar 文件作为 “app.jar” 添加到容器的 ENTRYPOINT 执行项目 app.jar。为了缩短 Tomcat 启动时间，添加一个系统属性指向 “/dev/./urandom” 作为 Entropy Source 如果是第一次打包，它会自动下载java 8的镜像作为基础镜像，以后再制作镜像的时候就不会再下载了。 4. 部署文件 在服务器新建一个docker文件夹，将maven打包好的jar包和Dockerfile文件复制到服务器的docker文件夹下 docker文件夹 5. 制作镜像 执行下面命令， 看好，最后面有个"."点！
|
1 |
docker build -t springbootdemo4docker . |
-t 参数是指定此镜像的tag名 制作完成后通过docker images命令查看我们制作的镜像 6.启动容器
|
1 2 3 |
[root@localhost docker]# docker run -d -p 8080:8085 springbootdemo4docker -d参数是让容器后台运行 -p 是做端口映射，此时将服务器中的8080端口映射到容器中的8085(项目中端口配置的是8085)端口 |
7. 访问网站 直接浏览器访问： http://你的服务器ip地址:8080/ 好了，下一步就是学习springboot+mysql+redis如何在docker上如何部署了。 作者：雄关漫道从头越 链接：https://www.jianshu.com/p/397929dbc27d 来源：简书 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
View Details缘由 我们在使用spring boot开发的服务中，一般会选择打包成单体的fatjar来发布服务，这在传统的部署方式下是非常方便的，但是当我们选择使用docker这种容器化的方式来部署应用的时候，却有一点点的不便之处，因为这个单体的jar一般都比较大，每次镜像push到仓库和从仓库拉取都需要比较长的时间。 原因是什么了？ docker的一大特色就是镜像的存储是分层的，参考下面这张官图 我们在Dockerfile中的每一个指令会对应到镜像的每一层，docker在更新镜像时，只会推送变更过的层，当它计算出来这一层的摘要和之前的版本一致时，会复用上一次打包镜像时的缓存，会极大的提高打包镜像以及镜像push/pull操作的速度。 那么问题来了，当我们springboot打包出来的单体jar的时候，每次编译这个jar都会发生变化，对应的存储层也会发生变化，push和pull操作时都需要重新推送，而且这个jar一般都不小，一个典型的应用会在100M左右，对应用部署和发布的速度会有比较大的影响。 稍作思考，很容易就能发现这个肥大的jar文件里面，大部分其实都是固定不变的各种依赖库，我们真正每次编译会变化的业务代码部分其实很小很小，可能也就只有几百KB，只要能将这两部分分离，变成docker镜像中的两层，一定能极大的提升镜像发布的速度 牛刀小试 首先拿来动手尝试的是一个springboot admin的项目，项目的结构是这样的： 使用最常见的打包方式：
|
1 2 3 4 |
<plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> </plugin> |
会生成一个32M的jar文件，优化之前的Dockerfile非常简单：
|
1 2 3 4 5 6 7 8 |
FROM openjdk:11.0.5-stretch as builder RUN ln -sf /usr/share/zoneinfo/Asia/Shanghai /etc/localtime RUN echo 'Asia/Shanghai' >/etc/timezone VOLUME /tmp COPY target/*.jar ./app.jar CMD ["/bin/bash", "-c", "java -jar -server app.jar"] EXPOSE 8080 |
可以看到这种方式在构建v2版本的镜像时，会重新copy整个完整的jar 如果要拆开这个单体的jar，有两种方式，一是修改mvn打包的配置，将lib包放在独立的文件夹下，在这里我们考虑到项目众多，尽量减少修改，选择了在Docker打包镜像时，解压打包出来的jar包，将其中的内容分开来copy，修改后的Dockerfile如下：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
#采用docker的分阶段构建方式，第一阶段负责解压jar包 FROM openjdk:11.0.5-stretch as builder RUN ln -sf /usr/share/zoneinfo/Asia/Shanghai /etc/localtime RUN echo 'Asia/Shanghai' >/etc/timezone VOLUME /tmp WORKDIR /target ADD target/*.jar app.jar RUN jar xf app.jar #这里分别copy解压后的内容 FROM openjdk:11.0.5-stretch VOLUME /tmp WORKDIR /app COPY --from=builder target/BOOT-INF/lib ./lib COPY --from=builder target/org/ ./org COPY --from=builder target/META-INF/ ./META-INF COPY --from=builder target/BOOT-INF/classes ./classes CMD ["/bin/bash", "-c", "java -cp .:./classes/:./lib/* -server org.springframework.boot.loader.JarLauncher"] EXPOSE 8080 |
看看修改后的效果： 在copy lib目录时，是直接using cache的。来看看push的时候效果对比 首先是优化前的push： 可以看到在push v2的时候还是会push一个33MB的层，虽然其实我们一行代码没有修改。 然后是优化后的： 可以看到这一次仅仅只推送了一个13KB的层，推送的速度快了非常多，同理也可以想象的到，我们在拉取镜像更新版本时速度会快很多。 路遇荆棘 在针对springboot-admin这个最简单的项目的优化取得很好的效果之后，就开始准备照搬到其他的项目中，没想到同样的方式怎么折腾都无效，分离之后的lib目录依然会每次需要全量重新push。出问题的项目结构大概是这样的： 一个常见的多模块mvn项目，有common，domain，rest-client，rest-server 这4个子模块，其中rest-server会依赖common和domain这两个子模块，打包出来的jar是在rest-server这个模块中。 究竟是什么鬼了？ 终得正果 苦苦思索一番之后，lib目录既然不能复用上一次的cache，那一定是因为里面的内容有变化，遂将jar包解压，进到lib目录，真凶果然在此： 项目自身的3个子模块在每次编译的时候也会做为jar包放到lib目录下，这3个jar包每次编译都会有变化，所以导致这一层的cache失效。 找到问题之后，解决的思路就很简单了，将这种jar单独copy到一个目录下即可，修改后的Dockerfile如下：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 |
FROM openjdk:11.0.5-stretch as builder RUN ln -sf /usr/share/zoneinfo/Asia/Shanghai /etc/localtime RUN echo 'Asia/Shanghai' >/etc/timezone VOLUME /tmp WORKDIR /target ADD target/*.jar app.jar RUN jar xf app.jar #创建一个snapshot目录，把snapshot的jar复制过去 RUN mkdir BOOT-INF/snapshot RUN mv BOOT-INF/lib/*SNAPSHOT.jar BOOT-INF/snapshot/ FROM openjdk:11.0.5-stretch VOLUME /tmp WORKDIR /app COPY --from=builder target/BOOT-INF/lib ./lib COPY --from=builder target/org/ ./org COPY --from=builder target/META-INF/ ./META-INF #单独复制snapshot这一层 COPY --from=builder target/BOOT-INF/snapshot ./snapshot COPY --from=builder target/BOOT-INF/classes ./classes CMD ["/bin/bash", "-c", "java -cp .:./classes/:./lib/*:./snapshot/* -server org.springframework.boot.loader.JarLauncher"] EXPOSE 8089 |
这样修改之后效果就和上面单模块的项目一样了，至此，基本完成了springboot项目的docker镜像优化，在jenkins的流水线上可以将原来镜像push的时间从1分钟以上优化到10s左右 未来之路 在整个优化的过程中，发现springboot2.3 M1版本已经有针对性的优化方案，增加了LAYERED_JAR的打包格式，未来可期。 具体可参考下文： www.jdon.com/53738 注： 本文中举例的两个项目案例，可在github上找到：github.com/yishh/sprin… 作者：thor_lee 链接：https://juejin.cn/post/6844904119338008583 来源：掘金 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
View Details遇到的问题： 公司java项目按老的方式打包出来一个fat jar，100MB, 推送到腾讯云镜像仓库很慢，8分钟。。。走的是公网，专线暂时还没配置好 以前是内网harbor，速度还不明显。 归根究底，一次推送100MB是个不合理的事情 思路： 了解spring boot打包，期望将依赖的libs 和 业务代码拆分 优化dockerfile，充分利用缓存 解决问题： 先修改spring-boot-maven-plugin，只打包业务代码。网上有些是配置exclude，我试了，恶心到了。。那么多包挨个找
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
<plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> <configuration> <!--<mainClass>cn.qg.clotho.Bootstrap</mainClass>--> <layout>ZIP</layout> <!--<executable>true</executable>--> <includes> <include> <groupId>${project.groupId}</groupId> <artifactId>${project.artifactId}</artifactId> </include> </includes> </configuration> </plugin> |
新增maven-dependency-plugin，将依赖移到libs目录下
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
<plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-dependency-plugin</artifactId> <executions> <execution> <id>copy</id> <phase>package</phase> <goals> <goal>copy-dependencies</goal> </goals> <configuration> <type>jar</type> <includeTypes>jar</includeTypes> <includeScope>runtime</includeScope> <outputDirectory>${project.build.directory}/libs</outputDirectory> </configuration> </execution> </executions> </plugin> |
优化dockerfile 参考 https://medium.com/@nieldw/caching-maven-dependencies-in-a-docker-build-dca6ca7ad612 ，牛逼
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
FROM mvn3.5 as builder WORKDIR /build COPY pom.xml . RUN mvn dependency:go-offline COPY src/ /build/src/ RUN mvn package FROM jdk1.8 EXPOSE 80 CMD exec java -Dloader.path="/home/libs/" -jar /home/app.jar COPY --from=builder /build/target/*.jar /home/app.jar COPY --from=builder /build/target/libs /home/libs/ |
搞定。最终代码变化每次推送也就1MB多 启动命令 java -Dloader.path="libs/" -jar app.jar 作者：小猋_a8f1 链接：https://www.jianshu.com/p/32456eea0488 来源：简书 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
View Details