Docker For Windows 32 Bit

2/12/2022by admin

In this post I describe how to create multi-architecture docker images. Specifically, I show how to create Docker images that run on ARM 64 processors (such as AWS's Graviton2 processors) from a Windows PC using Docker Desktop.

  1. Docker For Windows 10 32 Bit Download
  2. Docker Windows 32 Bit Image
  3. Docker Hub

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, and you can run images targeted for a different architecture on Docker Desktop too. 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. Yes, you can run a 32bit application inside of a container running Windows Server Core, it will run under WOW just as it would on a physical or virtual machine. Nano Server, the new minimal installation of Windows Server, doesn't have the WOW layer (one of the ways we've reduced the footprint) so you can only run 64bit applications on. Sep 29, 2016 For some reason, Docker really, really doesn’t want people to run on 32-bit. I’m sure they have their reasons, but I’ve got a Lenovo tablet with Windows 10 32-bit that I got for free and I.

Docker multi-arch images

Docker has the concept of multi-architecture images, which means that a single Docker image can support multiple architectures. Typically different OS/processor architectures require different Docker images. With multi-arch images you specify a single image, and Docker will pull the appropriate architecture for your processor and platform.

For example, if you specify the .NET SDK docker image in your Dockerfile:

Then on Windows, if you're using Windows containers, it will pull the appropriate Windows Nano Server container. This could be version 1809, 2004, or 20H2, depending on your host OS version.

On a Linux system, this would pull the x64, arm64, or arm32 image, depending on your host architecture!

While working on the CI for the Datadog Tracer, I wanted to use dadarek/docker-wait-for-dependencies to ensure docker-compose has started all the dependency containers before we run our integration tests.

The problem was that the dadarek/docker-wait-for-dependencies docker image doesn't support ARM64, so we were getting failures in CI when trying to run the image on Linux

In general, you can't run docker images that target a different processor architecture than your hose system. However, you can run Linux architectures like ARM64 on Windows using Docker Desktop. Docker Desktop uses the qemu-static emulator to make this cross-architecture emulation completely seamless!

As the repository and Dockerfile for dadarek/docker-wait-for-dependencies are open source, I decided to rebuild the dockerfile as a multi-arch file that supports ARM64. Luckily, this is very easy to do with Docker's new buildx command,

Creating multi-arch docker images with buildx

In this section I describe the steps I took, based on the documentation about the buildx command.

We start by cloning the docker-wait-for-dependencies repository:

You can see what platforms are supported by buildx by running docker buildx ls:


This lists the supported platforms you can build from. In my case, this includes the following platforms:

  • linux/amd64: Linux x64
  • linux/arm64: ARM 64
  • linux/riscv64: 64-bit RISC-V
  • linux/ppc64le: 64-bit little-endian PowerPC
  • linux/s390x: 64-bit Linux on IBM Z
  • linux/386: Linux x86
  • linux/arm/v7: ARM v7 (32-bit)
  • linux/arm/v6: ARM v6 (32-bit)

I'm running Docker Desktop on Windows, using Linux containers, with Docker version 20.10.5.

We start by creating a new builder that supports the multi-arch platforms, calling it mybuilder. Specifying --use sets this as the current builder:

Building a multi-arch image is as simple as using docker buildx build and passing the desired platforms using --platform as a comma separated list:

Using the following command, I built the docker image for multiple architectures, tagged it as andrewlock/wait-for-dependencies:latest, and pushed to docker hub:

If you don't want to push directly to a container registry, you can use --load to test it locally, but you can't test with multiple platforms yet unfortunately:

And that's it! If you view the image on Docker hub you can see that the image supports multiple architectures under the OS/ARCH column:

With that change, we could now run the docker image on ARM64 processors!


In this post, I discussed Docker multi-arch images, and how they can be used to easily run an image on multiple processor architectures such as ARM 64. I then showed how you can use buildx to build for multiple processor architectures using Docker Desktop. The whole process was incredibly simple and easy, and I quickly had a Docker container that would run on an ARM64 processor architecture!

Estimated reading time: 5 minutes

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

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

Docker ce for windows

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 imageon an x86_64 / amd64 machine, the x86_64 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 architecturessuch as arm, mips, ppc64le, and even s390x.

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

Build multi-arch images with Buildx

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

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

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

Build and run multi-architecture images

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

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

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

Switch to the new builder and inspect it.

Docker For Windows 10 32 Bit Download

Test the workflow to ensure you can build, push, and run multi-architectureimages. 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 cURLinstalled for multiple architectures.

Create a Dockerfile with the following:

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

Where, username is a valid Docker username.


  • 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 imagesto Docker Hub.

Inspect the image using docker buildx imagetools.

The image is now available on Docker Hub with the tag username/demo:latest. Youcan 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 thecurrent architecture, so Raspberry Pis run the 32-bit Arm version and EC2 A1instances 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. Forexample, when you run the following on a macOS:

Docker Windows 32 Bit Image

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.

Docker Hub

mac, windows, Multi-CPU architecture support
Comments are closed.