【超全教程】SpringBoot 2.3.x 分層構建 Docker 鏡像實踐

2021-02-13 java小組
目錄SpringBoot 2.3.x 新增對分層的支持普通鏡像構建腳本文件 dockerfile-number分層鏡像構建腳本文件 dockerfile-layer

系統環境:

Open JDK 基礎鏡像版本:openjdk:8u275

私有的 Harbor 鏡像倉庫:自建 Harbor 私庫

https://github.com/my-dlq/blog-example/tree/master/springboot/springboot-layer

參考地址:

https://docs.docker.com/storage/storagedriver/

一、什麼是鏡像分層

鏡像的構成

現在一談起鏡像大部分都是指 Docker 引擎構建的鏡像,一般 Docker 鏡像是由很多層組成,底層是作業系統,然後在其之上是基礎鏡像或者用戶自定義 Dockerfile 腳本中定義的中間層。

其中鏡像在構建完成後,用戶只能對鏡像進行讀操作,而不能進行寫操作,只有鏡像啟動後變為容器,才能進行讀寫操作。鏡像整體結構,可以觀看下圖:

該圖中展示了鏡像的基本組成,但是圖中這一個個中間層是什麼呢?要想了解這些層具體是什麼,那得知道如何構建 Docker 鏡像了。平時我們構建 Docker 鏡像時候,都是編寫 Dockerfile 腳本,然後使用 Docker 鏡像構建命令,按照腳本一行行執行構建。

如下就是一個 Dockerfile 腳本,腳本內容就構建 Java 項目鏡像常用的 Dockerfile 命令:

FROM openjdk:8u275
VOLUME /tmp
ADD target/*.jar app.jar
ENV TZ="Asia/Shanghai"
ENV JAVA_OPTS=""
ENV JVM_OPTS="-XX:MaxRAMPercentage=80.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 TZ="Asia/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:MaxRAMPercentage=80.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 TZ="Asia/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 TZ="Asia/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 依賴:

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

項目 pom.xml 中引入 spring-boot-maven-plugin 打包插件,並且開啟分層功能:

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <configuration>
                <!--開啟分層編譯支持-->
                <layers>
                    <enabled>true</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 -Djarmode=layertools -jar target/springboot-layer-0.0.1.jar list

可用該看到以下輸出,下面的內容就是接下來使用分層構建後,生成的 Jar 提取出對應資源後的結構:

dependencies
spring-boot-loader
snapshot-dependencies
application

上面即是使用分層工具提取 Jar 的內容後生成的文件夾,其中各個文件夾作用是:

dependencies: 存儲項目正常依賴 Jar 的文件夾。

snapshot-dependencies: 存儲項目快照依賴 Jar 的文件夾。

application: 用於存儲應用程式類相關文件的文件夾。

三、創建測試的 SpringBoot 應用

創建測試的 SpringBoot 項目,並且在 pom.xml 中開啟鏡像分層。

1、Maven 中引入相關依賴和插件
<?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>

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

    <artifactId>springboot-dockerfile-layer</artifactId>
    <packaging>jar</packaging>
    <name>springboot-dockerfile-layer</name>
    <description>springboot build layer example</description>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <layers>
                        <enabled>true</enabled>
                    </layers>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

2、創建測試的 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!";
    }

}

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 TZ="Asia/Shanghai"
RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone
ENV JVM_OPTS="-XX:MaxRAMPercentage=80.0"
ENV JAVA_OPTS=""
ENTRYPOINT [ "sh", "-c", "java $JAVA_OPTS -Djava.security.egd=file:/dev/./urandom -jar /app.jar $APP_OPTS" ]

說明:

TZ: 時區設置,而 Asia/Shanghai 表示使用中國上海時區。

JVM_OPTS: 指定 JVM 啟動時候的參數,-XX:MaxRAMPercentage 參數和 -Xmx 類似,都是限制堆內存大小,只不過 -Xmx 需要手動指定限制大小,而 -XX:MaxRAMPercentage 則是根據虛擬機可用內存百分比限制。

JAVA_OPTS: 在鏡像啟動時指定的自定義 Java 參數,例如 -Dspring.application.name=xxx。

2、分層鏡像構建腳本文件 dockerfile-layer
FROM openjdk:8u275 as builder
WORKDIR application
COPY target/*.jar application.jar
RUN java -Djarmode=layertools -jar application.jar extract

FROM openjdk:8u275
WORKDIR application
COPY --from=builder application/dependencies/ ./
COPY --from=builder application/snapshot-dependencies/ ./
COPY --from=builder application/spring-boot-loader/ ./
COPY --from=builder application/application/ ./
ENV TZ="Asia/Shanghai"
ENV JVM_OPTS="-XX:MaxRAMPercentage=80.0"
ENV JAVA_OPTS=""
ENTRYPOINT ["sh","-c","java $JVM_OPTS $JAVA_OPTS org.springframework.boot.loader.JarLauncher"]

說明:

TZ: 時區設置,而 Asia/Shanghai 表示使用中國上海時區。

-Djarmode=layertools: 指定構建 Jar 的模式。

extract: 從 Jar 包中提取構建鏡像所需的內容。

-from=builder 多級鏡像構建中,從上一級鏡像複製文件到當前鏡像中。

五、使用兩種 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.1

real    0m35.215s

## 第二次推送鏡像
$ time docker push hub.mydlq.club/library/springboot-normal:0.0.2

real    0m14.051s

## 第三次推送鏡像
$ time docker push hub.mydlq.club/library/springboot-normal:0.0.3

real    0m14.183s

伺服器二推送分層鏡像到鏡像倉庫2:

## 第一次推送鏡像
$ time docker push hub.mydlq.club/library/springboot-layer:0.0.1

real    0m34.121s

## 第二次推送鏡像
$ time docker push hub.mydlq.club/library/springboot-layer:0.0.2

real    0m13.605s

## 第三次推送鏡像
$ time docker push hub.mydlq.club/library/springboot-layer:0.0.3

real    0m4.805s

2、鏡像倉庫拉取鏡像測試

伺服器一推送從鏡像倉庫1拉取鏡像:

## 清理全部鏡像
$ docker rm --force $(docker images -qa)

## 拉取鏡像 springboot-normal:0.0.1
$ time docker push hub.mydlq.club/library/springboot-normal:0.0.1

real    0m35.395s

## 拉取鏡像 springboot-normal:0.0.2
$ time docker push hub.mydlq.club/library/springboot-normal:0.0.2

real    0m6.501s

## 拉取鏡像 springboot-normal:0.0.3
$ time docker push hub.mydlq.club/library/springboot-normal:0.0.3

real    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.1

real    0m30.615s

## 拉取鏡像 springboot-layer:0.0.2
$ time docker push hub.mydlq.club/library/springboot-normal:0.0.2

real    0m4.811s

## 拉取鏡像 springboot-layer:0.0.3
$ time docker push hub.mydlq.club/library/springboot-normal:0.0.3

real    0m1.293s

七、鏡像構建、推送、拉取時間匯總1、不使用分層構建鏡像

如下圖:

2、使用分層構建鏡像

如下圖:

3、總結

上面進行了使用 SpringBoot2.3.x 分層的方式構建鏡像與普通的方式構建鏡像,在鏡像的構建、推送、拉取方面進行了執行速度對比,總結出如下結論:

鏡像構建: 在構建上,使用分層 Jar 構建鏡像可能比普通方式構建鏡像更繁瑣,所以也更耗時,故而在構建上分層 Jar 構建鏡像沒有太多優勢。

鏡像推送: 在推送上,如果每次構建鏡像都只是修改構建鏡像項目的源碼,使用分層 Jar 構建鏡像,可以大大加快鏡像推送速度。如果是修改構建鏡像項目中的依賴包,則和普通構建一樣速度很慢。

鏡像拉取: 拉取和推送類似,如果只修改構建鏡像項目的源碼,只會拉取源碼相關的中間層鏡像,該層非常小(一般幾百KB),拉取速度自然非常快。而對構建鏡像項目的依賴包進行變動(增加依賴、刪除依賴、修改依賴版本等),則會和普通方式構建鏡像一樣,拉取速度很慢,這是因為依賴包層是中間層鏡像最大的一層(一般在10MB~200MB之間),如果該層發生變動則整個層會進行重新拉取,這樣速度自然會很慢。

相關焦點

  • Spring Boot 分層構建 Docker 鏡像實戰
    # SpringBoot 2.3.x 新增對分層的支持SpringBoot 2.3.x 以後支持分層打包應用,需要 Pom.xml 中引入 SpringBoot 2.3.x 後的父依賴和使用 SpringBoot 打包插件 spring-boot-maven-plugin,並且開啟 layers 功能,然後執行 Maven 編譯源碼構建 Jar 包,使用該 Jar
  • SpringBoot 項目構建 Docker 鏡像調優實踐
    1、準備編譯鏡像的 SpringBoot 項目這裡準備一個經過 Maven 編譯後的普通的 springboot 項目來進行 Docker 鏡像構建,項目內容如下圖所示,可以看到要用到的就是裡面的應用程式的 Jar 文件,將其存入鏡像內完成鏡像構建任務。
  • 使用Gradle構建SpringBoot項目Docker鏡像
    使用Gradle快速構建SpringBoot項目Docker鏡像,將鏡像推送到阿里雲遠程鏡像倉庫。
  • 基於Dockerfile構建容器鏡像的最佳實踐
    例如,放任各路repo研發自行寫Dockerfile,沒有一定的標準,前期可能無所謂,到後期問題就慢慢浮現了正所謂《能用就行》~3、Dockerfile 如何優化3.1 從哪裡入手優化docker鏡像應該從鏡像分層概念入手3.1.1 舉個慄子
  • SpringBoot第二十四篇: springboot整合docker
    這篇文篇介紹,怎麼為 springboot程序構建一個docker鏡像。docker 是一個開源的應用容器引擎,基於 Go 語言 並遵從Apache2.0協議開源。準備工作環境:linux環境或mac,不要用windowsjdk 8maven 3.0docker對docker一無所知的看docker教程。
  • 基於Docker的SpringBoot構建實踐
    然後利用Maven插件 dockerfile-maven-plugin 配置鏡像信息及鏡像構建。POM相關配置如下所示... target/${jarFileName}.jar app.jar# 設置鏡像的默認執行命令ENTRYPOINT java -jar app.jar# 聲明Web服務使用的埠EXPOSE 4001鏡像構建至此,對於一個SpringBoot服務而已,其構建鏡像所需的相關配置均已完成。
  • 【長篇博文】Docker學習筆記(三):鏡像的分層、打包、雙向綁定、導入導出、Dockerfile的構建、部署與發布
    可點擊以下連結查看往期文章:【長篇博文】Docker學習筆記與深度學習環境的搭建和部署(一)【長篇博文】Docker學習筆記與深度學習環境的搭建和部署(二)本文目錄一、鏡像分層的理解1.0、聯合文件1.1、加載鏡像1.2、分層拉取鏡像
  • 多平臺Docker鏡像構建教程
    那麼,你該如何為這些平臺構建鏡像?最明顯的方法是在目標平臺上構建鏡像。這適用於很多情況。但是如果你的目標是 s390x,我希望你有可以使用的 IBM 大型機。更常見的平臺,比如樹莓派、物聯網設備通常電量有限,速度慢或無法構建鏡像。我們該怎麼做?有兩個選項:1. 目標平臺仿真,2. 交叉編譯。有趣的是,我發現有種方法可以將這兩個選項結合的效果最好。
  • 基於k8s、docker、jenkins、springboot構建docker服務.
    本文介紹基於Jenkins + github  + k8s + springboot構建docker
  • 一個網站的微服務架構實戰docker和 docker-compose
    兩個文件放在同一目錄,執行構建鏡像的命令就可以了:docker build -t bees-mysql .現在通過 docker images,就能看到本地的鏡像庫中就已經新建了一個 bees-mysql的鏡像啦。SpringBoot鏡像springboot構建鏡像的方式很多,有通過代碼生成鏡像的,也有通過jar包生成鏡像的。
  • 理解Docker的多階段鏡像構建
    對於已經接納和使用Docker技術在日常開發工作中的開發者而言,構建Docker鏡像已經是家常便飯。但這是否意味著Docker的image構建機制已經相對完美了呢?不是的,Docker官方依舊在持續優化鏡像構建機制。這不,從今年發布的Docker 17.05版本起,Docker開始支持容器鏡像的多階段構建(multi-stage build)了。什麼是鏡像多階段構建呢?
  • 優化Spring Boot應用Docker鏡像,提高CI/CD效率
    如果你使用了CI/CD去構建部署Docker鏡像,你會發現有時候CI管道中構建的時間會很長,甚至卡住不動,特別在鏡像比較多的時候這種感覺非常明顯。所以我們項目要優化這個地方。Docker的分層機制要優化就要了解Docker鏡像的構建分層機制。Docker鏡像由很多層組成,每個層代表Dockerfile中的一條指令。
  • Docker系列教程04-Docker構建鏡像的三種方式
    簡介創建鏡像的方法主要有三種:基於已有鏡像的容器創建、基於本地模板導入、基於Dockerfile創建。今天就逐一講述為大家講述,如何構建屬於自己的docker鏡像。1、基於容器構建鏡像基於已有容器構建鏡像主要是通過docker commit命令來構建新的鏡像,語法規則如下:docker commit 語法下面將演示下如何基於已有容器構建鏡像1、首先,創建一個容器,並在其容器內創建一個test文件,之後退出。
  • 一分鐘玩轉Docker容器化部署
    Docker鏡像按照前面Docker的介紹,如果要讓Spring Boot程序運行在Docker容器上,首先需要構建Docker鏡像,而構建的過程則需要通過Dockerfile文件來描述。/urandom -jar  /app/springboot.jar這裡打包Spring Boot應用Docker鏡像的Dockerfile文件就定義好了,為了能在Maven項目中執行Docker鏡像構建命令,還需要在項目pom.xml文件添加Maven Build插件信息,代碼如下:<!
  • Docker鏡像
    分層存儲因為鏡像包含作業系統完整的root 文件系統,其體積往往是龐大的,因此在 Docker 設計時,就充分利用Union FS 的技術,將其設計為分層存儲的架構。所以 嚴格來說,鏡像並非是像一個 ISO 那樣的打包文件,鏡像只是一個虛擬的概念,其 實際體現並非由一個文件組成,而是由一組文件系統組成,或者說,由多層文件系 統聯合組成。
  • Docker 鏡像如何做到「一次構建,到處運行」?
    感謝最新版本 Docker 運行時環境帶來的實驗性擴展,構建多架構鏡像現在比以前方便多了。為了能夠更方便的構建多架構 Docker 鏡像,我們可以使用最近發布的 Docker 擴展:buildx。buildx 是下一代標準 docker build 命令的前端,既我們熟悉的用於構建 Docker 鏡像的命令。
  • 構建安全可靠、最小化的 Docker 鏡像
    本文將針對該問題,通過原理加實踐的方式,從頭到腳幫你擼一遍。文章比較長,主要通過五個部分對容器鏡像進行講解。分別是:鏡像的構建 講解了鏡像的手動構建與自動構建過程。鏡像的存儲與 UnionFS 聯合文件系統 講解了鏡像的分層結構以及 UnionFS 聯合文件系統,以及鏡像層在 UnionFS 上的實現。最小化鏡像構建 講解了為什麼需要最小化鏡像,同時如何進行最小化構建。
  • Maven構建Docker鏡像
    SpringBoot應構建Docker鏡像 本文主要介紹使用Maven將SpringBoot應用打包成Docker鏡像,並上傳到私有鏡像倉庫Docker Registry.鏡像倉庫Docker Registry的搭建 1.Pull Registry鏡像docker pull registry:22.鏡像倉庫的容器實例docker run -d -p 5000:5000 --restart=always --name registry
  • Docker鏡像瘦身與優化
    依賴文件和實際的代碼文件單獨分層團隊/公司採用公共的基礎鏡像等往往我們在構建階段和實際運行階段需要的依賴環境是不同的,例如Golang編寫的程序實際運行的時候僅僅需要一個二進位文件即可,對於Node來說,可能最後運行的只是一些打包之後的js文件而不需要包含node_modules裡成千上萬的依賴。
  • Spring Boot 2.0(四):使用 Docker 部署 Spring Boot
    @RestControllerpublic class DockerController { @RequestMapping("/") public String index() { return "Hello Docker!"