12

I have setup a build pipeline on an ARM device that is building a .NET Core application. The last step of the build pipeline would be to store the compiled .NET Core app in a docker image.

Is it possible to store the app in the .NET Core runtime image for X86?

My hope is that the .NET Core app does not care about the system architecture as long as the .NET framework is deployed. And that docker does not need to start the X86 image to generate the new image:

FROM mcr.microsoft.com/dotnet/core/aspnet:3.1

COPY /my-application/build/ /app/

EXPOSE 80/tcp

WORKDIR /app
ENTRYPOINT ["dotnet", "app.dll"]
jwillmer
  • 3,570
  • 5
  • 37
  • 73
  • I found something on the net here: http://github.com/dotnet/announcements/issues/27 The .NET Core offering for arm32v7 is quite limited currently. We wanted to make that obvious. Not sure if this helps. – Ziaullah Khan Jul 08 '20 at 11:06

1 Answers1

13

If I understand your question correctly you have a ARM machine running the pipeline and you want it to compile both the ARM and the x86 image?

Buildx - for cross-platform image building

Sure you can. You can use buildx to manage the cross-compiling for you. So go ahead and install buildx.

After you have setup buildx and configured it. You can just run:

docker buildx build \
  --platform linux/amd64,linux/386,linux/arm/v7 \
  --push \
  -t docker_user/docker_image:latest \
  .

Since the base image this will work for every platform you want. You can change the platforms you want to build for.

What buildx does, it emulate the target platform and execute all the steps in your regular docker file as if running on that platform. Buildx also tags the image, -t parameter. And Pushes it to the docker registry of choice, if you specify --push.

Actually it pushes an image per platform and a manifest file joining those images. If an other docker client wants to run the image, the manifest is loaded and the needed platform is selected.

In docker compiling

For this to work, you'll need to compile the image in the docker pipeline. That is recommended anyway because compiling it locally and then copying it to the container will result in different images depending on the the installed software on the machine building the image.

Follow the instructions here to created a needed dockerfile.

Requirements

For this to work the base image has to also support multiple architectures. You can check this in the docker registry. It is the case for the dotnet core images. But if your base image isn't supporting the platform it probably won't work. However recompiling the entire image should work (as long al the base image is supporting that platform).

See in action

You also have a github action for installing buildx in a github runner. I use this for several of my libraries, see this workflow file or the result here

Stephan
  • 2,356
  • 16
  • 38
  • I know about buildx but I thought this only works to compile ARM from x86 and not the other way around. Will test it! – jwillmer Jul 08 '20 at 14:36
  • 1
    According to [this page](https://tech.smartling.com/building-multi-architecture-docker-images-on-arm-64-c3e6f8d78e1c) someone else is doing it, so I think it should work. – Stephan Jul 08 '20 at 15:17
  • I'm not able to get it to work yet but the article is promising. I give you the bounty before it goes to waste. Thank you for pointing me in the right direction. – jwillmer Jul 09 '20 at 12:35