[Docker] Docker buildx support multiple architectures images

Posted on Edited on In , , , Views: Word count in article: 6.5k Reading time ≈ 6 mins.

Docker buildx with multi-CPU architecture support

Docker images can support multiple architectures, which means that a single image may contain variants for different architectures, and sometimes for different operating systems, such as Windows.

When running an image with multi-architecture support, docker automatically selects the image variant that matches your OS and architecture.

Most of the Docker Official Images on Docker Hub provide a variety of architectures. For example, the busybox image supports amd64, arm32v5, arm32v6, arm32v7, arm64v8, i386, ppc64le, and s390x. When running this image on an x86_64 / amd64 machine, the amd64 variant is pulled and run.

Multi-arch support on Docker Desktop

Docker Desktop provides binfmt_misc multi-architecture support, which means you can run containers for different Linux architectures such as arm, mips, ppc64le, and even s390x.

This does not require any special configuration in the container itself as it uses qemu-static from the Docker for Mac VM. Because of this, you can run an ARM container, like the arm32v7 or ppc64le variants of the busybox image.

Enable Docker Experimental

1
2
3
4
5
6
7
8
9
10
11
12
// daemon.json

{
  "builder": {
    "gc": {
      "defaultKeepStorage": "20GB",
      "enabled": true
    }
  },
  "debug": true,
+   "experimental": true
}

Build multi-arch images with Buildx

Docker is now making it easier than ever to develop containers on, and for Arm servers and devices. Using the standard Docker tooling and processes, you can start to build, push, pull, and run images seamlessly on different compute architectures. In most cases, you don’t have to make any changes to Dockerfiles or source code to start building for Arm.

Docker introduces a new CLI command called buildx. You can use the buildx command on Docker Desktop for Mac and Windows to build multi-arch images, link them together with a manifest file, and push them all to a registry using a single command. With the included emulation, you can transparently build more than just native images. Buildx accomplishes this by adding new builder instances based on BuildKit, and leveraging Docker Desktop’s technology stack to run non-native binaries.

For more information about the Buildx CLI command, see Buildx and the docker buildx command line reference.

Build and run multi-architecture images

Run the docker buildx ls command to list the existing builders. This displays the default builder, which is our old builder.

1
2
3
4
5
6
$ docker buildx ls
NAME/NODE       DRIVER/ENDPOINT STATUS  PLATFORMS
desktop-linux * docker
  desktop-linux desktop-linux   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/arm64, linux/riscv64, linux/ppc64le, linux/s390x, linux/386, linux/arm/v7, linux/arm/v6

Create a new builder which gives access to the new multi-architecture features.

1
2
3
4
5
6
7
8
9
10
$ docker buildx create --name mybuilder

$ docker buildx ls
NAME/NODE       DRIVER/ENDPOINT             STATUS   PLATFORMS
mybuilder       docker-container
  mybuilder0    unix:///var/run/docker.sock inactive
desktop-linux   docker
  desktop-linux desktop-linux               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/arm64, linux/riscv64, linux/ppc64le, linux/s390x, linux/386, linux/arm/v7, linux/arm/v6

Alternatively, run docker buildx create --name mybuilder --use to create a new builder and switch to it using a single command.

Switch to the new builder and inspect it.

1
2
3
4
5
6
$ docker buildx use mybuilder

$ docker buildx inspect --bootstrap
 [internal] booting buildkit                                                   2.5s
 => pulling image moby/buildkit:master                                         1.3s
 => creating container buildx_buildkit_mybuilder0                              1.2s

Test the workflow to ensure you can build, push, and run multi-architecture images. Create a simple example Dockerfile, build a couple of image variants, and push them to Docker Hub.

The following example uses a single Dockerfile to build an Ubuntu image with cURL installed for multiple architectures.

Create a Dockerfile with the following:

1
2
3
4
# Dockerfile

FROM ubuntu:20.04
RUN apt-get update && apt-get install -y curl

Build the Dockerfile with buildx, passing the list of architectures to build for:

1
2
3
$ docker buildx build --platform linux/amd64,linux/arm64,linux/arm/v7 -t username/demo:latest --push .
 => pushing layers                                                             2.7s
 => pushing manifest for docker.io/username/demo:latest                       2.2

Where, username is a valid Docker username.

Notes:

  • The --platform flag informs buildx to generate Linux images for AMD 64-bit, Arm 64-bit, and Armv7 architectures.

  • The --push flag generates a multi-arch manifest and pushes all the images to Docker Hub.

Inspect the image using docker buildx imagetools.

1
$ docker buildx imagetools inspect username/demo:latest

The image is now available on Docker Hub with the tag username/demo:latest. You can use this image to run a container on Intel laptops, Amazon EC2 A1 instances, Raspberry Pis, and on other architectures. Docker pulls the correct image for the current architecture, so Raspberry Pis run the 32-bit Arm version and EC2 A1 instances run 64-bit Arm. The SHA tags identify a fully qualified image variant. You can also run images targeted for a different architecture on Docker Desktop.

You can run the images using the SHA tag, and verify the architecture. For example, when you run the following on a macOS:

1
2
3
$ docker run --rm docker.io/username/demo:latest@sha256:2b77acdfea5dc5baa489ffab2a0b4a387666d1d526490e31845eb64e3e73ed20 uname -m

$ docker run --rm docker.io/username/demo:latest@sha256:723c22f366ae44e419d12706453a544ae92711ae52f510e226f6467d8228d191 uname -m

In the above example, uname -m returns aarch64 and armv7l as expected, even when running the commands on a native macOS or Windows developer machine.

FAQs

multiple platforms feature is currently not supported for docker driver. Please switch to a different driver (eg. “docker buildx create --use”)

1
2
3
$ docker buildx build --platform linux/amd64,linux/arm64,linux/arm/v7 -t username/demo:latest --push .
error: multiple platforms feature is currently not supported for docker driver. Please switch to a different driver (eg. "docker buildx create --use")
make: *** [docker-build-tag] Error 1

Create a new builder which gives access to the new multi-architecture features, then use it.

1
2
3
4
5
$ docker buildx create --name mybuilder

$ docker buildx use mybuilder

# $ docker buildx create --name mybuilder --use

References

[1] Leverage multi-CPU architecture support | Docker Documentation - https://docs.docker.com/desktop/multi-arch/

[2] Docker Buildx | Docker Documentation - https://docs.docker.com/buildx/working-with-buildx/#build-with-buildx

[3] docker buildx build | Docker Documentation - https://docs.docker.com/engine/reference/commandline/buildx_build/

[4] QEMU - https://wiki.qemu.org/Main_Page

[5] build-push-action/multi-platform.md at master · docker/build-push-action - https://github.com/docker/build-push-action/blob/master/docs/advanced/multi-platform.md

[6] Learn GitHub Actions - GitHub Docs - https://docs.github.com/en/actions/learn-github-actions

[7] Encrypted secrets - GitHub Docs - https://docs.github.com/en/actions/reference/encrypted-secrets

[8] Github - https://github.com/

[9] Docker Hub - https://hub.docker.com/