多平台容器鏡像構建就看這一篇

前言

願景與現實

早在1995年，就有“write once and run anywhere”（WORA，編寫一次即可在任何地方運行）用於描述 Java 應用程序。時過20年，Docker 高聲喊出了自己的口號——“Build Once, Run Anywhere”（一次構建，隨處可用）。

願望是美好的，然而，現實總比理想骨感。 Linux、Windows 這些不同的操作系統擁有不同的系統 API； x86、Arm、IBM PowerPC 這些不同的硬件平台的指令集不同，某些同平台的硬件甚至擁有不同的專用指令集用於加速應用。一次構建，隨處可用面臨着巨大的挑戰，要構建能夠在不同操作系統、不同硬件平台的運行的應用程序，仍然需要工程師們針對具體的操作系統和硬件平台進行海量的移植工作。

Why and How

既然多平台的支持這么麻煩、充滿挑戰，我們是不是可以放棄支持？然而隨着國產化大潮和 IoT 物聯網的來臨，我們編寫的應用程序不僅僅會在X86服務器上運行，新時代的工程師們不得不面對更多的硬件平台，放棄多平台的支持無疑是放棄更寬廣的未來。多平台的支持，勢在必行。

我們正處在一個波瀾壯闊的大時代中，新技術、新工具在一次次的迭代升級，不斷從Proposal （提議）到 Prototype（原型），再逐漸的實用化。

虛擬化技術使得我們可以做到模擬其它硬件平台；Docker 等容器技術打破混亂，讓開發、編譯、運行環境一致化；Golang、Rust 這樣原生支持多系統多平台的編程語言屏蔽大量底層差異，降低跨平台應用的開發難度。這一系列前人智慧火花匯聚到一起，發生了奇妙的反應——WORA 真正變的觸手可及，夢想的陽光已經照進現實。

本篇章會大量分析技術原理及實現細節，對於希望快速 GET 可執行方案的同學，可以直接跳轉到【可執行方案回顧】查看。

如何支持多平台

要了解容器鏡像是如何支持多平台的，那我們需要仔細聊聊 Manifest。使用過容器技術的同學都知道，我們運行容器所使用的鏡像是由多層構成的，而這些層的清單和其它容器信息共同存放在 Manifest 當中。

Manifest

我們通常使用的容器鏡像是x86平台的，執行 docker manifest inspect harbor-community.tencentcloudcr.com/multi-arch/alpine 命令可以查看鏡像 harbor-community.tencentcloudcr.com/multi-arch/alpine 的 Manifest 內容是一個 JSON 對象（如代碼段-01所示）。各個字段的解釋如下：

1. mediaType 字段聲明這是一個V2 Manifes。
2. schemaVersion 版本。
3. config 鏡像配置信息。
4. layers 鏡像層信息。

// 代碼段-01
{
	"schemaVersion": 2,
	"mediaType": "application/vnd.docker.distribution.manifest.v2+json",
	"config": {
		"mediaType": "application/vnd.docker.container.image.v1+json",
		"size": 1507,
		"digest": "sha256:f70734b6a266dcb5f44c383274821207885b549b75c8e119404917a61335981a"
	},
	"layers": [
		{
			"mediaType": "application/vnd.docker.image.rootfs.diff.tar.gzip",
			"size": 2813316,
			"digest": "sha256:cbdbe7a5bc2a134ca8ec91be58565ec07d037386d1f1d8385412d224deafca08"
		}
	]
}

顯而易見的是，Manifest 當中並沒有任何字段描述鏡像的平台信息。那應該怎么樣支持多平台呢？

我們可以設想一個簡單粗暴的，無視鏡像的平台，強行把交叉編譯出來的其它平台的二進制程序添加到鏡像內，使用 Repository 名稱或者 Tag 名稱來區分不同平台的鏡像，例如 coredns/coredns:coredns-arm64。在使用的時候，人工或者通過腳本判斷應該拉取那個鏡像。

Schema 2

Ohhhhh，這當然可以跑起來，但是難免太挫了吧？事實上，早在2015年底 Docker 社區的 manifest v2.2 規格文檔（也叫 Schema 2，參見 https://github.com/docker/distribution/blob/master/docs/spec/manifest-v2-2.md ）中就提及了多平台鏡像，該功能通過 manifest list(也叫做 fat manifest) 引用多個不同平台鏡像的 Manifest 實現。

首先讓我們看看 manifest 是什么樣的，執行 docker manifest inspect alpine 命令可以查看Docker Hub 上的多平台鏡像 alpine 的 Manifest。

// 代碼段-02
{
   "schemaVersion": 2,
   "mediaType": "application/vnd.docker.distribution.manifest.list.v2+json",
   "manifests": [
      {
         "mediaType": "application/vnd.docker.distribution.manifest.v2+json",
         "size": 528,
         "digest": "sha256:a15790640a6690aa1730c38cf0a440e2aa44aaca9b0e8931a9f2b0d7cc90fd65",
         "platform": {
            "architecture": "amd64",
            "os": "linux"
         }
      },
      {
         "mediaType": "application/vnd.docker.distribution.manifest.v2+json",
         "size": 528,
         "digest": "sha256:71465c7d45a086a2181ce33bb47f7eaef5c233eace65704da0c5e5454a79cee5",
         "platform": {
            "architecture": "arm",
            "os": "linux",
            "variant": "v6"
         }
      },
      {
         "mediaType": "application/vnd.docker.distribution.manifest.v2+json",
         "size": 528,
         "digest": "sha256:c929c5ca1d3f793bfdd2c6d6d9210e2530f1184c0f488f514f1bb8080bb1e82b",
         "platform": {
            "architecture": "arm",
            "os": "linux",
            "variant": "v7"
         }
      },
      {
         "mediaType": "application/vnd.docker.distribution.manifest.v2+json",
         "size": 528,
         "digest": "sha256:3b3f647d2d99cac772ed64c4791e5d9b750dd5fe0b25db653ec4976f7b72837c",
         "platform": {
            "architecture": "arm64",
            "os": "linux",
            "variant": "v8"
         }
      },
      {
         "mediaType": "application/vnd.docker.distribution.manifest.v2+json",
         "size": 528,
         "digest": "sha256:90baa0922fe90624b05cb5766fa5da4e337921656c2f8e2b13bd3c052a0baac1",
         "platform": {
            "architecture": "386",
            "os": "linux"
         }
      },
      {
         "mediaType": "application/vnd.docker.distribution.manifest.v2+json",
         "size": 528,
         "digest": "sha256:5d950b30f229f0c53dd7dd7ed6e0e33e89d927b16b8149cc68f59bbe99219cc1",
         "platform": {
            "architecture": "ppc64le",
            "os": "linux"
         }
      },
      {
         "mediaType": "application/vnd.docker.distribution.manifest.v2+json",
         "size": 528,
         "digest": "sha256:a5426f084c755f4d6c1d1562a2d456aa574a24a61706f6806415627360c06ac0",
         "platform": {
            "architecture": "s390x",
            "os": "linux"
         }
      }
   ]
}

可以看出來 manifest list 是一個 JSON 數組，數組當中應用了不同平台鏡像的 Manifest。所以，推送多平台鏡像時，我們需要先分別推送不同平台的鏡像層；然后創建 manifest list ， 再引用平台鏡像的 Manifest，最后把 manifest list 上傳到 Registry 服務。而拉取鏡像時，客戶端應當設置 HTTP 的請求頭字段 Accept 值為 application/vnd.docker.distribution.manifest.v2+json和application/vnd.docker.distribution.manifest.list.v2+json，然后檢查服務端返回的響應頭字段Content-Type 判斷是舊鏡像格式，新鏡像格式或者時鏡像清單。

拋開規格文檔來說，只要我們使用的 Registry 服務的 Distribution 版本不低於 v2.3，Docker CLI 版本不低於 v1.10 就能過支持多平台鏡像功能。

構建多平台鏡像

要構建多平台的容器鏡像，我們需要確保容器基礎鏡像和應用程序的代碼或者二進制都是目標平台的。

程序代碼

一些編程語言的編譯器能夠為其它平台編譯二進制文件，最為著名的包括 Golang 和 Rust。我們將使用 Golang 編寫一個演示用 web 程序——通過 HTTP 訪問查看 web 服務程序的操作系統、硬件平台等信息。具體代碼如代碼段-03 所示。

// 代碼段-03
package main
import (
	"net/http"
	"runtime"
	"github.com/gin-gonic/gin"
)
var (
	r = gin.Default()
)
func main() {
	r.GET("/", indexHandler)
	r.Run(":9090")
}
func indexHandler(c *gin.Context) {
	var osinfo = map[string]string{
		"arch":    runtime.GOARCH,
		"os":      runtime.GOOS,
		"version": runtime.Version(),
	}
	c.JSON(http.StatusOK, osinfo)
}

我們在 MacOS 上使用 go run 運行代碼段-03， httpie 工具訪問本機:9090 端口，將會看見如下信息。

代碼准備好了，現在我們有兩種構建方法：手動編譯，使用 docker build 構建鏡像；使用 docker buildx 工具自動化編譯構建。

手動編譯構建

前置條件

• Dockerd 啟用 experimental

我們需要在 Docker daemon 配置文件中配置 "experimental": true開啟實驗性功能：

$ vi /etc/docker/daemon.json
{
  "experimental": true
}

修改 Docker daemon 配置需要重啟服務使配置生效：

$ sudo systemctl restart docker.service

使用 docker version 命令查看版本信息，配置生效后可以看到 Server: Docker Engine 中有 Experimental: true ：

$ sudo docker version
Client: Docker Engine - Community
 Version:           19.03.12
 API version:       1.40
 Go version:        go1.13.10
 Git commit:        48a66213fe
 Built:             Mon Jun 22 15:45:36 2020
 OS/Arch:           linux/amd64
 Experimental:      false
Server: Docker Engine - Community
 Engine:
  Version:          19.03.12
  API version:      1.40 (minimum version 1.12)
  Go version:       go1.13.10
  Git commit:       48a66213fe
  Built:            Mon Jun 22 15:44:07 2020
  OS/Arch:          linux/amd64
  Experimental:     true
 containerd:
  Version:          1.2.13
  GitCommit:        7ad184331fa3e55e52b890ea95e65ba581ae3429
 runc:
  Version:          1.0.0-rc10
  GitCommit:        dc9208a3303feef5b3839f4323d9beb36df0a9dd
 docker-init:
  Version:          0.18.0
  GitCommit:        fec3683
`

如果您使用的 Docker CLI 版本低於 v20.10 ，執行 docker manifest 命令會看到報錯提示 docker manifest is only supported on a Docker cli with experimental cli features enabled ，此時我們需要執行 export DOCKER_CLI_EXPERIMENTAL="enabled" 開啟客戶端實驗特性支持。在 v20.10 及以上版本的 Docker CLI 會默認開啟實驗特性，無需額外操作。

交叉編譯

在我們的 Golang 代碼中沒有使用 CGO 的時候，通過簡單設置環境變量就能夠交叉編譯出其它平台和操作系統上能夠執行的二進制文件。其中：

1. GOARCH 用於指定編譯的目標平台，如 amd64、arm64、riscv64 等平台。
2. GOOS 用於指定編譯的目標系統，如 darwin、linux。

本篇中，我們構建能夠在 Linux 發行版中執行的容器鏡像，所以編譯目標系統環境變量GOOS統一設置為linux。執行代碼段0-4中的命令構建出二進制文件備用。

// 代碼段-04
#!/bin/bash
IMAGE?=kofj/multi-demo
NOCOLOR:='\033[0m'
RED:='\033[0;31m'
GREEN:='\033[0;32m'
BUILD_ARCH?=$(uname -m)
BUILD_OS?=$(uname -s)
BUILD_PATH:=build/docker/linux
LINUX_ARCH?=amd64 arm64 riscv64
LDFLAGS:="-s -w -X github.com/kofj/multi-arch-demo/cmd/info.BuildArch=$(BUILD_ARCH) -X github.com/kofj/multi-arch-demo/cmd/info.BuildOS=$(BUILD_OS)"
for arch in ${LINUX_ARCH}; do
	echo ===================;
	echo ${GREEN}Build binary for ${RED}linux/$$arch${NOCOLOR};
	echo ===================;
	GOARCH=$$arch GOOS=linux go build -o ${BUILD_PATH}/$$arch/webapp -ldflags=${LDFLAGS} -v cmd/main.go;
done

構建各個平台的鏡像

首先，我們編寫一個 Dockerfile用於構建鏡像。

FROM scratch
LABEL authors="Fanjian Kong"
ADD webapp /app/
WORKDIR /app
CMD ["/app/webapp"]

然后，分別構建不同平台的鏡像，可以使用如代碼段-05的腳本幫助構建。

// 代碼段-05
#!/bin/bash
IMAGE?=kofj/multi-demo
NOCOLOR:='\033[0m'
RED:='\033[0;31m'
GREEN:='\033[0;32m'
LINUX_ARCH?=amd64 arm64 riscv64
BUILD_PATH:=build/docker/linux
for arch in ${LINUX_ARCH}; do
	echo =================== ;
	echo ${GREEN}Build docker image for ${RED}linux/$$arch${NOCOLOR} ;
	echo =================== ;
	cp Dockerfile.slim ${BUILD_PATH}/$$arch/Dockerfile ;
	docker build -t ${IMAGE}:$$arch ${BUILD_PATH}/$$arch ;
done

創建 Manifest List

我們使用docker manifest 子命令管理 manifest list。其中，docker manifest create 子命令用於在本地創建一個 manifest list。該命令需要指定待 manifest list 地址和一系列的 manifests。例如需要創建包含amd64和 arm64 兩個平台鏡像的 manifest list，則命令如：

docker manifest create kofj/multi-demo kofj/multi-demo:amd64 kofj/multi-demo:arm64

docker manifest create 命令的詳細幫助信息如下所示：

# docker manifest create --help
Usage:	docker manifest create MANIFEST_LIST MANIFEST [MANIFEST...]
Create a local manifest list for annotating and pushing to a registry
Options:
  -a, --amend      Amend an existing manifest list
      --insecure   Allow communication with an insecure registry

我們按照上述方法創建出來的 manifest list 中並沒有說明其中的 manifest 是什么操作系統和平台的，docker manifest annotate 命令用於注釋創建出來的 manifest list。例如注釋某個 manifest 是 linxu系統 arm64 平台的，則命令：

docker manifest annotate kofj/multi-demo kofj/multi-demo:arm64 --os linux --arch arm64

docker manifest annotate 命令的詳細幫助信息如下所示：

# docker manifest annotate --help
Usage:	docker manifest annotate [OPTIONS] MANIFEST_LIST MANIFEST
Add additional information to a local image manifest
Options:
      --arch string           Set architecture
      --os string             Set operating system
      --os-features strings   Set operating system feature
      --variant string        Set architecture variant

注意：

1. 創建 manifest list 清單的過程中會檢查遠端倉庫中 manifests 是否存在，所以我們必修提前推送鏡像到遠端。如果遠端倉庫是不安全的，在創建的過程中需要添加參數 --inseure。
2. 使用 docker manifest annotate 注釋 manifest list 的時候不需要使用--insecure。

為了方便使用，我們可以使用下述代碼段-06 的腳本創建 manifest list。

// 代碼段-06
#!/bin/bash
IMAGE?=kofj/multi-demo
NOCOLOR:='\033[0m'
RED:='\033[0;31m'
GREEN:='\033[0;32m'
LINUX_ARCH?=amd64 arm64 riscv64
IMAGES=$(foreach arch,$(LINUX_ARCH),$(IMAGE):$(arch))
@echo ${GREEN}Create manifest for ${RED} \( ${LINUX_ARCH}\) ${NOCOLOR};
@docker manifest create ${IMAGE} ${IMAGES}
@for arch in ${LINUX_ARCH}; do \
	echo ${GREEN}Annotate manifest ${RED}linux/$$arch${NOCOLOR}; \
	echo ===================; \
	docker manifest annotate ${IMAGE} ${IMAGE}:$$arch --os linux --arch $$arch; \
done

推送 manifest list

當我們完成 manifest list 的創建工作后，它還是存儲在本地的。這時候，還需要推送到遠端的鏡像倉庫。與推送普通鏡像不同，推送 manifest list 需要使用 docker manifest push 命令進行。如果我們要推送 kofj/multi-demo 這個 manifest list，則命令如：

docker manifest push kofj/multi-demo

使用 docker manifest push 命令可以通過附加--purge 選項在推送完成后刪除存儲在本地的 manifest list； 當我們的目標倉庫沒有使用或者使用了非可信 TLS 證書的時候，則需要使用 --insecure 選項。

buildx 自動構建

軟件依賴

• Docker >= 19.03: 自該 Docker 版本包含 buildx。
• Linux kernel >= 4.8: 自該Linux內核版本 binfmt_misc 支持 fix-binary (F) flag。fix_binary 標志允許內核在容器或chroot內使用binfmt_misc注冊的二進制格式處理程序，即使該處理程序二進制文件不是該容器或chroot內可見的文件系統的一部分。
• binfmt_misc file system mounted: 需要掛載binfmt_misc文件系統，以便用戶空間工具可以控制此內核功能，即注冊和啟用處理程序。
• Docker Desktop >= 2.1.0 如果是使用的 Docker Desktop。

Environment	Docker 安裝包	Kernel	binfmt-support	(F) Flag
需求	>= 19.03	>= 4.8	>= 2.1.7	yes
Ubuntu:
18.04 (bionic)	17.12.1 docker.io	4.15.0	2.1.8	yes
19.04 (disco)	18.09.5 docker.io	5.0	2.2.0	yes
19.10 (eoan)	19.03.2 docker.io	5.3	2.2.0	yes
20.04 (focal)	19.03.2 docker.io	5.5	2.2.0	yes
Debian:
9 (stretch)	-	4.9.0	2.1.6	no
10 (buster)	18.09.1 docker.io	4.19.0	2.2.0	yes
11 (bullseye/testing)	19.03.4 docker.io	5.4	2.2.0	yes
騰訊雲
Ubuntu 16.04 (xenial)	18.09.7 docker.io	4.4.0	2.1.6-1	no
Ubuntu 18.04 (bionic)	19.03.6 docker.io	4.15.0	2.1.8-2	yes
亞馬遜 EC2:
Ubuntu 16.04 (xenial)	18.09.7 docker.io	4.4.0	2.1.6	no
Ubuntu 18.04 (bionic)	18.09.7 docker.io	4.15.0	2.1.8	yes
Travis (谷歌 GCP):
Ubuntu 14.04 (trusty)	17.09.0 docker-ce	4.4.0	2.1.4	no
Ubuntu 16.04 (xenial)	18.06.0 docker-ce	4.15.0	2.1.6	no
Ubuntu 18.04 (bionic)	18.06.0 docker-ce	4.15.0	2.1.8	yes
Github Actions (微軟 Azure):
Ubuntu 16.04 (xenial)	3.0.8 moby-engine	4.15.0	2.1.6	no
Ubuntu 18.04 (bionic)	3.0.8 moby-engine	5.0.0	2.1.8	yes

配置 Buildx

buildx 從 19.03 開始與 Docker CE 捆綁發布，但是需要我們在 Docker CLI 上啟用實驗性功能開開啟。可以通過兩種方式啟用它：

1. 將 "experimental": "enabled” 添加到 Docker CLI 的配置文件 ~/.docker/config.json。
2. 另外一種方法時設置環境變量 DOCKER_CLI_EXPERIMENTAL=enabled。

使用 Docker Desktop 的同學可以通過 UI 菜單 Preferences → Command Line 進入 Docker CLI 配置界面，通過Switch 開關 Enable experimental features啟用實驗性功能。

image-20201006100313617.png

如果需要使用最新版本的 buildx，可以從 https://github.com/docker/buildx/releases/latest 下載最新的二進制發行版，並將其復制到~/.docker/cli-plugins文件夾中，重命名為docker-buildx，然后更改執行權限：

chmod +x ~/.docker/cli-plugins/docker-buildx

最后讓我們驗證 buildx 是否已經可用了：

$ docker buildx version
github.com/docker/buildx v0.3.1-tp-docker 6db68d029599c6710a32aa7adcba8e5a344795a7

配置 binfmt_misc

QEMU 是一個很棒的開源項目，它可以模擬很多平台。將 QEMU 和 Docker 結合起來使用能使得我們更容易的構建跨平台的容器鏡像。集成 QEMU依賴於 Linux 內核功能 。Linux 內核中的 binfmt_misc功能可以使得內核識別任意類型的可以執行文件格式，並傳遞到特定的用戶空間應用程序和虛擬機（https://zh.wikipedia.org/wiki/Binfmt_misc）。當 Linux 遇到一種無法識別的可執行文件格式（比如說其它平台的可執行文件格式）時，它會檢查有沒有配置任何“用戶空間應用程序”用於處理它。如果檢測到了，就將可執行文件傳遞給該應用程序。

為此，我們需要在內核當中注冊其它平台的可執行文件格式。

對於使用 Docker Desktop（MacOS 和 Windows 上都是）的同學，因為默認配置了 binfmt_misc，可以跳過這一步。而使用 Linux 發行版操作系統的同學則需要自行安裝配置 binfmt_misc，以便能夠非原生的其它平台的鏡像。

要在宿主機上執行其它 CPU 平台的指令，需要安裝 QEMU 模擬器。因為程序執行時會在當前程序可見的文件系統中查找動態庫，而在容器或chroot環境中注冊的處理程序在其它的 cgroup namespace 中可能無法找到，所以需要靜態編譯連接的QEMU。同時，我們需要安裝一個包含足夠新的update-binfmts二進制文件的包，以便能夠支持fix-binary（F）標志，並在注冊QEMU模擬器時實際使用，這樣才能結合 buildx 一起鏡像跨平台構建。

QEMU 和 binfmt_misc 支持工具可以通過宿主機或者Docker 容器鏡像安裝。但是，使用Docker鏡像安裝配置能讓事情變得更加簡單。鏡像 docker/binfmt 中包含QEMU二進制文件和在binfmt_misc中注冊QEMU的安裝腳本。

docker run --privileged docker/binfmt:66f9012c56a8316f9244ffd7622d7c21c1f6f28d

執行完后，我們驗證下是否注冊成功了。成功注冊后，/proc/sys/fs/binfmt_misc 目錄中會有多個qemu-前綴的文件。查看 /proc/sys/fs/binfmt_misc/qemu-aarch64 文件內容，可以看到 falgs 標志為 OCF，說明這個處理程序是通過 （F）標志注冊的，能夠正常的結合 buildx 完成跨平台構建。

 ⚡ root@kofj-hk ~ ls -al /proc/sys/fs/binfmt_misc
total 0
drwxr-xr-x 2 root root 0 Oct 12 20:19 .
dr-xr-xr-x 1 root root 0 Oct 12 20:19 ..
-rw-r--r-- 1 root root 0 Oct 12 20:19 python2.7
-rw-r--r-- 1 root root 0 Oct 12 20:19 python3.6
-rw-r--r-- 1 root root 0 Oct 12 20:21 qemu-aarch64
-rw-r--r-- 1 root root 0 Oct 12 20:21 qemu-arm
-rw-r--r-- 1 root root 0 Oct 12 20:21 qemu-ppc64le
-rw-r--r-- 1 root root 0 Oct 12 20:21 qemu-s390x
--w------- 1 root root 0 Oct 12 20:19 register
-rw-r--r-- 1 root root 0 Oct 12 20:19 status
 ⚡ root@kofj-hk ~ cat /proc/sys/fs/binfmt_misc/qemu-aarch64
enabled
interpreter /usr/bin/qemu-aarch64
flags: OCF
offset 0
magic 7f454c460201010000000000000000000200b7
mask ffffffffffffff00fffffffffffffffffeffff

使用 buildx 構建

前置依賴注備好后，我們終於可以使用 buildx 構建多平台鏡像了。與其它方案不同的是，使用 buildx 可以讓我們不必改動 dockerfile。

Buildx 始終使用 BuildKit 引擎構建鏡像，不需要配置環境變量DOCKER_BUILDKIT=1。BuildKit 可以很好的用於多個平台的構建，而不僅適用於我們當前構建鏡像時所使用的平台和操作系統。進行構建時，使用 --platform標志可以用於指定構建輸出的目標平台（例如 linux/amd64，linux/arm64,linux/riscv64）。

首先，我們先准備好 Dockerfile 文件：

FROM golang:1.14 as builder
COPY . /src
WORKDIR /src
RUN ls -al && go build -a -tags netgo -ldflags '-w' -mod=vendor -v -o /src/bin/webapp /src/cmd/main.go
# Final image
FROM ubuntu:18.04
LABEL authors="Fanjian Kong"
COPY --from=builder /src/bin/webapp /app/
WORKDIR /app
CMD ["/app/webapp"]

然后，讓我們嘗試下運行 buildx。

✘ ⚡ root@kofj-hk ~ docker buildx build --platform linux/amd64,linux/arm64,linux/arm -t harbor-community.tencentcloudcr.com/multi-arch/demo:2020-10-12 . --push
error: auto-push is currently not implemented for docker driver, please create a new builder instance

居然報錯 error: auto-push is currently not implemented for docker driver, please create a new builder instance 了！別擔心，這是因為 Docker 默認的 builder 是不支持多平台構建的。我們可以通過 docker buildx ls 查看當前節點上的 builder 有哪些。

 ⚡ root@kofj-hk ~ docker buildx  ls
NAME/NODE DRIVER/ENDPOINT STATUS  PLATFORMS
default * docker
  default default         running linux/amd64, linux/386

為了使用多平台構建功能，我們需要新建一個 builder，並設置當前 builder 為新建的。

# 新建同時切換 builder 
docker buildx create --use --name mybuilder
# 只新建，然后再切換 builder
docker buildx create --name mybuilder
docker buildx use mybuilder

現在，讓我們再次執行 buildx，看着一切向着期待的方向發展了。

注意事項

⚠️注意1：到目前位置，buildx支持 linux/amd64, linux/386, linux/arm/v7, linux/arm/v6, linux/arm64, linux/ppc64le, linux/s390x。所以 docker/binfmt 鏡像僅注冊了 arm、ppc64le 和 s390x 的處理程序。如果你需要構建、運行 RISC-V 平台的容器鏡像，建議使用 multiarch/qemu-user-static 鏡像鏡像配置。

docker run --rm --privileged multiarch/qemu-user-static --reset -p yes

⚠️注意2：在 軟件依賴 中我們提到需要 Linux 內核版本 >= 4.8.0；如果在內核版本為 3.10.0 的系統（比如 CentOS）上運行 docker/binfmt，會出現報錯 Cannot write to /proc/sys/fs/binfmt_misc/register: write /proc/sys/fs/binfmt_misc/register: invalid argument，這是由於內核不支持 （F）標志造成的。出現這種情況，建議您升級系統內核或者換使用較高版本內核的 Linux 發行版。

小結

多年前，大規模部署應用程序是一項非常耗費人力、財力、時間，還需要大量技能和技巧的事務，工程師們還需要應對應用程序所運行的每一台服務器的環境差異。這對大公司而言是個極其沉重的負擔，小公司更是無力應對。

正如多年前人們無法想象大規模部署復雜的應用程序只需要一個 kubectl create 命令，不久前我們也不會想到構建多平台的容器鏡像只需要一個 docker buildx build。但是，我們還有更加廣闊的想象空間，自動化流程、更多平台的支持、更智能簡單的工具，你能想到的都有可能在不久的將來變成現實。

技術的發展進步，不斷降低了生產活動中社會平均勞動時間，提升了生產力，能夠釋放勞動者去做更多有益的探索。讓我們不斷學習、擁抱、應用新技術，在時代的浪潮中勇往直前。

可執行方案回顧

1. 確保使用的 Linux 發行版內核>=4.8.0（推薦使用 Ubuntu 18.04 以上的 TLS 發行版），且 Docker >= 19.03；
2. 啟用Docker CLI 實驗性功能： export DOCKER_CLI_EXPERIMENTAL=enabled；
3. 配置其它平台的模擬器：docker run --privileged docker/binfmt:66f9012c56a8316f9244ffd7622d7c21c1f6f28d；
4. 新建 Docker builder 實例支持多平台構建： docker buildx create --use --name mybuilder；
5. 在項目目錄中執行構建： docker buildx build --platform linux/amd64,linux/arm64,linux/arm -t harbor-community.tencentcloudcr.com/${YOUR_NAMESPACE}/multi-arch:2020-10-12 . --push。
6. 相關演示代碼、腳本可以在 https://github.com/kofj/multi-arch-demo.git 獲取。

推廣時間

目前，騰訊雲容器鏡像服務 TCR已完成公測進入商業化階段。我們也已經對部分用戶開放了 Multi Arch 鏡像和 OCI 雲原生制品支持。如果您對該功能感興趣，歡迎聯系客服開通。

【騰訊雲原生】雲說新品、雲研新術、雲游新活、雲賞資訊，掃碼關注同名公眾號，及時獲取更多干貨！！