Using Docker Buildx to Build Images for Multiple System Architectures
Docker Buildx is a docker CLI plug-in that extends the docker command to support the functionality provided by Moby BuildKit. Provides the same user experience as docker build and adds many new features.
BuildKit is a next-generation image building component with many main features. This article mainly uses its feature of compiling multiple system architectures.
URL:https://github.com/moby/buildkit
It should be noted that this feature is only available for Docker v19.03+.
This article will explain how to use Buildx to build images for various system architectures.
Before you start, you have already installed 64-bit Docker under Linux system (major distributions) by default.
At the time of writing this article, the latest version number of Docker is 19.03.13.
$ docker version
Client: Docker Engine - Community Version: 19.03.13 API version: 1.40 Go version: go1.13.15 Git commit: 4484c46d9d Built: Wed Sep 16 17:03:45 2020 OS/Arch: linux/amd64 Experimental: true Server: Docker Engine - Community Engine: Version: 19.03.13 API version: 1.40 (minimum version 1.12) Go version: go1.13.15 Git commit: 4484c46d9d Built: Wed Sep 16 17:02:21 2020 OS/Arch: linux/amd64 Experimental: false containerd: Version: 1.3.7 GitCommit: 8fba4e9a7d01810a393d5d25a3621dc101981175 runc: Version: 1.0.0-rc10 GitCommit: dc9208a3303feef5b3839f4323d9beb36df0a9dd docker-init: Version: 0.18.0 GitCommit: fec3683
1. Enable Buildx
The buildx command is an experimental feature, so you need to enable it first.
In the content returned by checking the Docker version above, ifExperimental: trueThe words indicate that this feature has been turned on. This next step can be omitted.
Edit the ~/.docker/config.json file and add the following content (the following demonstration is applicable when the .docker directory does not exist in advance)
$ mkdir ~/.docker
$ cat > ~/.docker/config.json <<EOF
{
"experimental": "enabled"
}
EOF
Under Linux/macOS or by setting environment variables (not recommended):
$ export DOCKER_CLI_EXPERIMENTAL=enabled
2. Create a new builder instance
Available in Docker 19.03+ version docker buildx build The command uses BuildKit to build the image.This command supports --platform Parameters can simultaneously build Docker images that support multiple system architectures, greatly simplifying the construction steps.
Since Docker's default builder instance does not support specifying multiple --platform we must first create a new builder instance.
$ docker buildx create --name mybuilder --driver docker-container
Returns the new builder instance name, which is “mybuilder”
mybuilder
Use the newly created builder instance
$ docker buildx use mybuilder
View existing builder instances
$ docker buildx ls NAME/NODE DRIVER/ENDPOINT STATUS PLATFORMS mybuilder * docker-container mybuilder0 unix:///var/run/docker.sock inactive default docker default default running linux/amd64, linux/386
Docker does not support arm architecture images under the Linux/amd64 system architecture, so we can run a new container (emulator) to support this feature. Docker desktop version does not require this setting.
method one:
$ docker run --rm --privileged docker/binfmt:a7996909642ee92942dcd6cff44b9b95f08dad64
Note: docker/binfmt can refer to the URL:https://hub.docker.com/r/docker/binfmt/tags Get the latest image
Method two (recommended):
$ docker run --rm --privileged tonistiigi/binfmt --install all
Go to the reference website:https://hub.docker.com/r/tonistiigi/binfmt Get the latest image.Currently (updated on 2021/04/20) Qemu version: 5.0.0
3. Create a new Dockerfile file
To build images for multiple system architectures, a supporting Dockerfile is also required.
Below is a sample Dockerfile.
Reference links:https://github.com/teddysun/across/blob/master/docker/kms/Dockerfile.architecture
The content of the Dockerfile file is as follows:
FROM --platform=$TARGETPLATFORM alpine:latest AS builder
WORKDIR /root
RUN apk add --no-cache git make build-base && \
git clone --branch master --single-branch https://github.com/Wind4/vlmcsd.git && \
cd vlmcsd/ && \
make
FROM --platform=$TARGETPLATFORM alpine:latest
LABEL maintainer="Teddysun <(email protected)>"
COPY --from=builder /root/vlmcsd/bin/vlmcsd /usr/bin/vlmcsd
EXPOSE 1688
CMD ( "vlmcsd", "-D", "-e" )
$TARGETPLATFORM is a built-in variable, represented by --platform parameter to specify its value.
Since it is based on mirror of alpineto make, and alpine It supports the following 7 system architectures, so the images we make also support these 7 system architectures.
linux/amd64, linux/arm/v6, linux/arm/v7, linux/arm64, linux/386, linux/ppc64le, linux/s390x
A more friendly schema name is as follows:
amd64, arm32v6, arm32v7, arm64v8, i386, ppc64le, s390x
Here is a comment interspersed.
After a brief statistics, ARM’s system architecture has the following abbreviations:
arm64, armv8l, arm64v8, aarch64 arm, arm32, arm32v7, armv7, armv7l, armhf arm32v6, armv6, armv6l, arm32v5, armv5, armv5l, armel, aarch32
After reading this, do you want to hit someone?
Comparing Intel and AMD is much simpler:
x86, 386, i386, i686 x86_64, x64, amd64
4. Build the image
Let’s build one locally first.
git clone the sample Dockerfile just now and enter its directory
$ cd ~ && git clone https://github.com/teddysun/across.git && cd across/docker/kms/
Build images locally that support 7 platforms
$ docker buildx build --platform linux/amd64,linux/arm/v6,linux/arm/v7,linux/arm64,linux/ppc64le,linux/s390x,linux/386 -t teddysun/kms -o type=local,dest=.docker -f ./Dockerfile.architecture .
For the specific parameter meanings of docker buildx build, please refer to the official document below
https://docs.docker.com/engine/reference/commandline/buildx_build/
After completing the above step, you actually place the built image in the local path.
At this point let's take a look at the existing builder instances.
$ docker buildx ls NAME/NODE DRIVER/ENDPOINT STATUS PLATFORMS mybuilder * docker-container mybuilder0 unix:///var/run/docker.sock running linux/amd64, linux/arm64, linux/riscv64, linux/ppc64le, linux/s390x, linux/386, linux/arm/v7, linux/arm/v6 default docker default default running linux/amd64, linux/386
You will find that there are 8 supported architectures under mybuilder (riscv64 is not currently available, but it is supported).
At this time, check the running status of docker image and you will find that there is a file called buildx_buildkit_mybuilder0 container is running.
This was automatically created when building locally just now. Remember not to stop it or delete it.
$ docker ps -as CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES SIZE be753fa16090 moby/buildkit:buildx-stable-1 "buildkitd" 15 minutes ago Up 15 minutes buildx_buildkit_mybuilder0 0B (virtual 78.6MB)
Then build a multi-system architecture image and push the built image to the Docker warehouse (that is, hub.docker.com）。
Before this operation, you need to register an account in advance (the demonstration process is omitted) and log in.
The login command is as follows:
$ docker login
Enter your username and password to log in.
Note that in the following demonstrated command, the tag is preceded by my user name. teddysunif you want to make your own mirror, please replace it with your own username.
use --push The image built with parameters is pushed to the Docker warehouse.
At this time, it is still in the ~/across/docker/kms directory just now, and the file Dockerfile.architecture It is prepared for multi-system architecture construction.
The command is as follows:
$ docker buildx build --platform linux/386,linux/amd64,linux/arm/v6,linux/arm/v7,linux/arm64,linux/ppc64le,linux/s390x -t teddysun/kms --push -f ./Dockerfile.architecture .
After the command is executed successfully, you will see the image you uploaded in Docker Hub. An example diagram is as follows:
5.
When making a Docker image with a multi-system architecture, it is recommended to use a VPS with a strong CPU or multi-core to build it, otherwise it will be very time-consuming.