如何阿里巴巴网站做推广方案,怎么做网站的浏览栏,品牌推广计划书怎么写,网站建设技术论坛目录[-]
. 一、什么是镜像分层. 二、SpringBoot 2.3.x 新增对分层的支持. 三、创建测试的 SpringBoot 应用. 1、Maven 中引入相关依赖和插件. 2、创建测试的 Controller 类. 3、创建 SpringBoot 启动类. 四、创建两种构建镜像的 Dockerfile 脚本. 1、普通镜像构建脚本文件 doc…目录[-]
. 一、什么是镜像分层. 二、SpringBoot 2.3.x 新增对分层的支持. 三、创建测试的 SpringBoot 应用. 1、Maven 中引入相关依赖和插件. 2、创建测试的 Controller 类. 3、创建 SpringBoot 启动类. 四、创建两种构建镜像的 Dockerfile 脚本. 1、普通镜像构建脚本文件 dockerfile-number. 2、分层镜像构建脚本文件 dockerfile-layer. 五、使用两种 Dockerfile 构建项目镜像. 1、在服务器一构建普通 Docker 镜像. 2、在服务器二构建分层 Docker 镜像. 六、镜像推送到镜像仓库测试. 1、推送镜像到镜像仓库测试. 2、镜像仓库拉取镜像测试. 七、镜像构建、推送、拉取时间汇总. 1、不使用分层构建镜像. 2、使用分层构建镜像. 3、总结系统环境
Docker 版本 19.03.13Open JDK 基础镜像版本 openjdk:8u275私有的 Harbor 镜像仓库 自建 Harbor 私库项目 Github SpringBoot 2.3.x 分层构建 Docker 镜像示例
参考地址
Docker 官方文档-镜像分层机制介绍
一、什么是镜像分层
镜像的构成
现在一谈起镜像大部分都是指 Docker 引擎构建的镜像一般 Docker 镜像是由很多层组成底层是操作系统然后在其之上是基础镜像或者用户自定义 Dockerfile 脚本中定义的中间层。其中镜像在构建完成后用户只能对镜像进行读操作而不能进行写操作只有镜像启动后变为容器才能进行读写操作。镜像整体结构可以观看下图 该图中展示了镜像的基本组成但是图中这一个个中间层是什么呢要想了解这些层具体是什么那得知道如何构建 Docker 镜像了。平时我们构建 Docker 镜像时候都是编写 Dockerfile 脚本然后使用 Docker 镜像构建命令按照脚本一行行执行构建。
如下就是一个 Dockerfile 脚本脚本内容就构建 Java 项目镜像常用的 Dockerfile 命令
FROM openjdk:8u275
VOLUME /tmp
ADD target/*.jar app.jar
ENV TZAsia/Shanghai
ENV JAVA_OPTS
ENV JVM_OPTS-XX:MaxRAMPercentage80.0
ENTRYPOINT [sh,-c,java $JVM_OPTS $JAVA_OPTS -jar /app.jar]有了 Dockerfile 脚本我们需要执行 Docker 的构建镜像命令对执行 Dockerfile 脚本构建镜像其中构建镜像的过程如下
## 构建镜像的命令
$ docker build -t java-test:latest . ## 命令执行的过程
Step 1/7 : FROM openjdk:8u275--- 82f24ce79de6
Step 2/7 : VOLUME /tmp--- Running in a6361fdfc193
Removing intermediate container a6361fdfc193--- a43948bf1b98
Step 3/7 : ADD target/*.jar app.jar--- 18f4bc60818f
Step 4/7 : ENV TZAsia/Shanghai--- Running in cc738aa5865b
Removing intermediate container cc738aa5865b--- 538adb85609e
Step 5/7 : ENV JAVA_OPTS--- Running in f8b635d32b2b
Removing intermediate container f8b635d32b2b--- 34e7a8cd7b6e
Step 6/7 : ENV JVM_OPTS-XX:MaxRAMPercentage80.0--- Running in 9331cb6e443e
Removing intermediate container 9331cb6e443e--- 232b9c6c1d29
Step 7/7 : ENTRYPOINT [sh,-c,java $JVM_OPTS $JAVA_OPTS -jar /app.jar ]--- Running in c3a24fba3a10
Removing intermediate container c3a24fba3a10--- a41974d5f0e3可以看到总共存在 7 个构建步骤每步都与 Dockerfile 里面一行指令对应。样子和下图相似 如果这时候我们改变原来 Dockerfile 内容创建一个新的镜像其 Dockerfile 如下
FROM openjdk:8u275
VOLUME /tmp
ADD target/*.jar app.jar
ENV TZAsia/Macao #与原来 Dockerfile 不同
ENV JVM_OPTS-Xmx512m -Xss256k #与原来 Dockerfile 不同
ENTRYPOINT [sh,-c,java $JVM_OPTS $JAVA_OPTS -jar /app.jar ]执行 Docker 命令构建镜像
$ docker build -t java-test2:latest .Step 1/6 : FROM openjdk:8u275--- 82f24ce79de6
Step 2/6 : VOLUME /tmp--- Using cache--- a43948bf1b98
Step 3/6 : ADD target/*.jar app.jar--- Using cache--- 18f4bc60818f
Step 4/6 : ENV TZAsia/Macao--- Running in fd98b90a5485
Removing intermediate container fd98b90a5485--- afab3fcdab07
Step 5/6 : ENV JVM_OPTS-Xmx512m -Xss256k--- Running in 19a99576fba9
Removing intermediate container 19a99576fba9--- 4eeab7d7c720
Step 6/6 : ENTRYPOINT [sh,-c,java $JVM_OPTS $JAVA_OPTS -jar /app.jar ]--- Running in 2dba72e1eef4
Removing intermediate container 2dba72e1eef4--- 7c706ecf7698可以观察到执行过程中从一开始执行的构建步骤中显示并没有生成新的中间层镜像而是直接使用了已经存在的缓存镜像。直至 4⁄6 这部中由于新的 Dockerfile 与原来 Dockerfile 发生变动所以这部中间层镜像直接是新创建的并没有使用缓存中间层镜像。
然后往下观察发现之后的全部构建都是新创建的中间层镜像即是脚本最后的一行和原来相同也没有使用缓存中间层镜像。
上面现象说明Docker 镜像在构建过程中按照 Dockerfile 自上往下的执行顺序中如果从最上层开始其脚本内容和已有的缓存中间层镜像内容一致就会引入缓存中的中间层镜像并不是直接复制缓存镜像而是引入镜像文件地址多个镜像共享这些中间层镜像。但是如果执行过程中中间任意一行镜像构建的内容发生变化那么当前行和之后的全部行在执行时就不会使用缓存中的中间层镜像而是全部创建新的镜像。 这就是 Docker 镜像中缓存中间层镜像的复用学会使用缓存构建镜像将大大减少存储空间的占用以及镜像的构建的构建速度镜像的缓存不仅仅体现在镜像的构建上在执行”镜像推送”、”镜像拉取”操作时都能观察到其的好处。
镜像缓在镜像推送的体现 如镜像推送时候也是将镜像整体构成的中间层镜像并行推送到镜像仓库如果镜像仓库中已经存某个中间层镜像那么推送过程就不会再次将该层镜像推送到镜像仓库而是将仓库中并不存在中间层镜像推送到其中。镜像缓存在镜像拉取的体现 在拉取镜像时候如果本地某个大镜像的中间层镜像的组成中已经包含新拉取镜像的中间层部分镜像那么将直接复用本地已经镜像的中间层镜像不必再将其进行拉取而本地不存在的中间层镜像将会被继续拉取。
说了这么多相信大家已经对镜像缓存的使用有了初步了解那么再谈及为什么需要镜像分层就很好解释其原因就是 Docker 想提高资源的复用率将一个大镜像拆分成很多层小镜像组成以达到镜像中间层的复用的目的。
二、SpringBoot 2.3.x 新增对分层的支持
SpringBoot 2.3.x 以后支持分层打包应用需要 Pom.xml 中引入 SpringBoot 2.3.x 后的父依赖和使用 SpringBoot 打包插件 spring-boot-maven-plugin并且开启 layers 功能然后执行 Maven 编译源码构建 Jar 包使用该 Jar 包就可以构建基于分层模式的 Docker 镜像
项目 pom.xml 中引入 SpringBoot 2.3.x 依赖
parentgroupIdorg.springframework.boot/groupIdartifactIdspring-boot-starter-parent/artifactIdversion2.3.6.RELEASE/versionrelativePath/
/parent项目 pom.xml 中引入 spring-boot-maven-plugin 打包插件并且开启分层功能
buildpluginsplugingroupIdorg.springframework.boot/groupIdartifactIdspring-boot-maven-plugin/artifactIdconfiguration!--开启分层编译支持--layersenabledtrue/enabled/layers/configuration/plugin/plugins
/build执行 Maven 命令构建分层的 JAR 包命令和平时的 Maven 构建命令相同
$ mvn install观察 Jar 结构可以看到里面多了 classpath.idx 与 layers.idx 两个文件
classpath.idx 文件列出了依赖的 jar 包列表到时候会按照这个顺序载入。layers.idx 文件清单记录了所有要被复制到 Dokcer 镜像中的文件信息。
根据官方介绍在构建 Docker 镜像前需要从 Jar 中提起出对应的分层文件到 Jar 外面可用使用下面命令列出可以从分层 Jar 中提取出的文件夹信息
$ java -Djarmodelayertools -jar target/springboot-layer-0.0.1.jar list可用该看到以下输出下面的内容就是接下来使用分层构建后生成的 Jar 提取出对应资源后的结构
dependencies
spring-boot-loader
snapshot-dependencies
application上面即是使用分层工具提取 Jar 的内容后生成的文件夹其中各个文件夹作用是
dependencies 存储项目正常依赖 Jar 的文件夹。snapshot-dependencies 存储项目快照依赖 Jar 的文件夹。resources 用于存储静态资源的文件夹。application 用于存储应用程序类相关文件的文件夹。
三、创建测试的 SpringBoot 应用
创建测试的 SpringBoot 项目并且在 pom.xml 中开启镜像分层。
1、Maven 中引入相关依赖和插件
?xml version1.0 encodingUTF-8?
project xmlnshttp://maven.apache.org/POM/4.0.0xmlns:xsihttp://www.w3.org/2001/XMLSchema-instancexsi:schemaLocationhttp://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsdmodelVersion4.0.0/modelVersionparentgroupIdorg.springframework.boot/groupIdartifactIdspring-boot-starter-parent/artifactIdversion2.3.6.RELEASE/version/parentartifactIdspringboot-dockerfile-layer/artifactIdpackagingjar/packagingnamespringboot-dockerfile-layer/namedescriptionspringboot build layer example/descriptiondependenciesdependencygroupIdorg.springframework.boot/groupIdartifactIdspring-boot-starter-web/artifactId/dependency/dependenciesbuildpluginsplugingroupIdorg.springframework.boot/groupIdartifactIdspring-boot-maven-plugin/artifactIdconfigurationlayersenabledtrue/enabled/layers/configuration/plugin/plugins/build/project2、创建测试的 Controller 类
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;RestController
public class TestController {GetMapping(/hello)public String hello() {return hello world!;}}3、创建 SpringBoot 启动类
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;SpringBootApplication
public class Application {public static void main(String[] args) {SpringApplication.run(Application.class, args);}}四、创建两种构建镜像的 Dockerfile 脚本
为了方便体现出 SpringBoot 2.3.x 支持的分层构建 Dockerfile 的优点这里在 Java 源码文件夹下创建普通与分层两种构建镜像的 Dockerfile 脚本后续会使用这两种脚本构建 Docker 镜像进行构建速度、推送速度、拉取速度的对比。
1、普通镜像构建脚本文件 dockerfile-number
FROM openjdk:8u275
VOLUME /tmp
ADD target/*.jar app.jar
RUN sh -c touch /app.jar
ENV TZAsia/Shanghai
RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime echo $TZ /etc/timezone
ENV JVM_OPTS-XX:MaxRAMPercentage80.0
ENV JAVA_OPTS
ENTRYPOINT [ sh, -c, java $JAVA_OPTS -Djava.security.egdfile:/dev/./urandom -jar /app.jar $APP_OPTS ]说明
TZ 时区设置而 Asia/Shanghai 表示使用中国上海时区。JVM_OPTS 指定 JVM 启动时候的参数-XX:MaxRAMPercentage 参数和 -Xmx 类似都是限制堆内存大小只不过 -Xmx 需要手动指定限制大小而 -XX:MaxRAMPercentage 则是根据虚拟机可用内存百分比限制。JAVA_OPTS 在镜像启动时指定的自定义 Java 参数例如 -Dspring.application.namexxx。
2、分层镜像构建脚本文件 dockerfile-layer
FROM openjdk:8u275 as builder
WORKDIR application
COPY target/*.jar application.jar
RUN java -Djarmodelayertools -jar application.jar extractFROM openjdk:8u275
WORKDIR application
COPY --frombuilder application/dependencies/ ./
COPY --frombuilder application/snapshot-dependencies/ ./
COPY --frombuilder application/spring-boot-loader/ ./
COPY --frombuilder application/application/ ./
ENV TZAsia/Shanghai
ENV JVM_OPTS-XX:MaxRAMPercentage80.0
ENV JAVA_OPTS
ENTRYPOINT [sh,-c,java $JVM_OPTS $JAVA_OPTS org.springframework.boot.loader.JarLauncher]说明
TZ 时区设置而 Asia/Shanghai 表示使用中国上海时区。-Djarmodelayertools 指定构建 Jar 的模式。extract 从 Jar 包中提取构建镜像所需的内容。-frombuilder 多级镜像构建中从上一级镜像复制文件到当前镜像中。
五、使用两种 Dockerfile 构建项目镜像
1、在服务器一构建普通 Docker 镜像
(1)、第一次构建
## 执行 Maven 命令将源代码构建 Jar 包
$ mvn clean install## 构建 SpringBoot 应用的 Docker 镜像
$ time docker build -t hub.mydlq.club/library/springboot-normal:0.0.1 .Docker 镜像构建总共花费 24.98s 时间。
(2)、第二次构建修改依赖 pom.xml 文件
## 修改 pom.xml 里面的依赖随意添加一个新的依赖包然后再次将源代码构建 Jar 包
$ mvn clean install## 构建 SpringBoot 应用的 Docker 镜像
$ time docker build -t hub.mydlq.club/library/springboot-normal:0.0.2 .Docker 镜像构建总共花费 1.27s 时间。
(3)、第三次构建修改代码内容
## 修改源代码任意内容后然后再次将源代码构建 Jar 包
$ mvn clean install## 构建 SpringBoot 应用的 Docker 镜像
$ time docker build -t hub.mydlq.club/library/springboot-normal:0.0.3 .Docker 镜像构建总共花费 1.32s 时间。
2、在服务器二构建分层 Docker 镜像
(1)、第一次构建
## 执行 Maven 命令将源代码构建 Jar 包
$ mvn clean install## 构建 SpringBoot 应用的 Docker 镜像
$ time docker build -t hub.mydlq.club/library/springboot-layer:0.0.1 .Docker 镜像构建总共花费 26.12s 时间。
(2)、第二次构建修改依赖 pom.xml 文件
## 修改 pom.xml 里面的依赖随意添加一个新的依赖包然后再次将源代码构建 Jar 包
$ mvn clean install## 构建 SpringBoot 应用的 Docker 镜像
$ time docker build -t hub.mydlq.club/library/springboot-layer:0.0.2 .Docker 镜像构建总共花费 3.44s 时间。
(3)、第三次构建修改代码内容
## 修改源代码任意内容后然后再次将源代码构建 Jar 包
$ mvn clean install## 构建 SpringBoot 应用的 Docker 镜像
$ time docker build -t hub.mydlq.club/library/springboot-layer:0.0.3 .Docker 镜像构建总共花费 2.82s 时间。
六、镜像推送到镜像仓库测试
1、推送镜像到镜像仓库测试
服务器一推送普通镜像到镜像仓库1
## 第一次推送镜像
$ time docker push hub.mydlq.club/library/springboot-normal:0.0.1real 0m35.215s## 第二次推送镜像
$ time docker push hub.mydlq.club/library/springboot-normal:0.0.2real 0m14.051s## 第三次推送镜像
$ time docker push hub.mydlq.club/library/springboot-normal:0.0.3real 0m14.183s服务器二推送分层镜像到镜像仓库2
## 第一次推送镜像
$ time docker push hub.mydlq.club/library/springboot-layer:0.0.1real 0m34.121s## 第二次推送镜像
$ time docker push hub.mydlq.club/library/springboot-layer:0.0.2real 0m13.605s## 第三次推送镜像
$ time docker push hub.mydlq.club/library/springboot-layer:0.0.3real 0m4.805s2、镜像仓库拉取镜像测试
服务器一推送从镜像仓库1拉取镜像
## 清理全部镜像
$ docker rm --force $(docker images -qa)## 拉取镜像 springboot-normal:0.0.1
$ time docker push hub.mydlq.club/library/springboot-normal:0.0.1real 0m35.395s## 拉取镜像 springboot-normal:0.0.2
$ time docker push hub.mydlq.club/library/springboot-normal:0.0.2real 0m6.501s## 拉取镜像 springboot-normal:0.0.3
$ time docker push hub.mydlq.club/library/springboot-normal:0.0.3real 0m6.993s服务器二推送从镜像仓库2拉取镜像
## 清理全部镜像
$ docker rm --force $(docker images -qa)## 拉取镜像 springboot-layer:0.0.1
$ time docker push hub.mydlq.club/library/springboot-normal:0.0.1real 0m30.615s## 拉取镜像 springboot-layer:0.0.2
$ time docker push hub.mydlq.club/library/springboot-normal:0.0.2real 0m4.811s## 拉取镜像 springboot-layer:0.0.3
$ time docker push hub.mydlq.club/library/springboot-normal:0.0.3real 0m1.293s七、镜像构建、推送、拉取时间汇总
1、不使用分层构建镜像
次数\阶段构建(s)推送(s)拉取(s)第一次构建24.9835.2135.39第二次构建-修改依赖包1.2714.056.50第三次构建-修改代码1.3214.186.99
如下图 2、使用分层构建镜像
次数\阶段构建(s)推送(s)拉取(s)第一次构建26.1234.1230.61第二次构建-修改依赖包3.4413.604.81第三次构建-修改代码2.824.801.29
如下图 3、总结
上面进行了使用 SpringBoot2.3.x 分层的方式构建镜像与普通的方式构建镜像在镜像的构建、推送、拉取方面进行了执行速度对比总结出如下结论
镜像构建 在构建上使用分层 Jar 构建镜像可能比普通方式构建镜像更繁琐所以也更耗时故而在构建上分层 Jar 构建镜像没有太多优势。镜像推送 在推送上如果每次构建镜像都只是修改构建镜像项目的源码使用分层 Jar 构建镜像可以大大加快镜像推送速度。如果是修改构建镜像项目中的依赖包则和普通构建一样速度很慢。镜像拉取 拉取和推送类似如果只修改构建镜像项目的源码只会拉取源码相关的中间层镜像该层非常小一般几百KB拉取速度自然非常快。而对构建镜像项目的依赖包进行变动增加依赖、删除依赖、修改依赖版本等则会和普通方式构建镜像一样拉取速度很慢这是因为依赖包层是中间层镜像最大的一层一般在10MB~200MB之间如果该层发生变动则整个层会进行重新拉取这样速度自然会很慢。
—END—
