How to use buildkit instead of docker imagetools create to merge multiple architecture images into one manifest

[yulinor]

When building a multi-architecture image, if the introduced package file itself has architectural differences, you need to build image-amd and image-arm with different dockerfiles, and then use docker imagetools create to merge the two images and then push them, but I see buildkit It seems that this function is not supported?
So if there is, I can't explain how to use it. If not, I hope it will be a follow-up function.

[AkihiroSuda]

You can just use buildctl build --frontend dockerfile.v0 --opt platform=linux/amd64,linux/arm64
https://github.com/moby/buildkit/blob/master/docs/multi-platform.md

[yulinor]

First of all thanks for your reply, but it's not what I expected.
When using docker buildx, if the file introduced by the ADD command in the dockerfile itself distinguishes the architecture, you need to write at least two dockerfiles and correspondingly produce image-arm and image-amd. For example, the jdk file distinguishes x86 and arm. So before I used docker buildx to build, I used the command buildx build -t jdkimage-arm and jdkimage-amd to build the specified architecture respectively, and then used the command docker imagetools create to merge the two images into jdkimage.
But I see that buildkit does not support merging heterogeneous images into a multi-architecture image address.
If you have a solution please let me know, thank you.

[yulinor]

Maybe the previous statement is not clear, let me express it again.
Previously, I referenced JDK files of different architectures, created different base images, and then used commands to merge the two.

# jdk-amd64.dockerfile
FROM alpine
ADD jdk_x86.tar.gz /opt

# jdk-arm64.dockerfile
FROM alpine
ADD jdk_arm.tar.gz /opt

docker buildx build -t registry.com/jdk/jdk:amd --platform=linux/amd64 --push . -f jdk-amd64.dockerfile
docker buildx build -t registry.com/jdk/jdk:arm  --platform=linux/arm64 --push . -f jdk-arm64.dockerfile
docker buildx imagetools create -t registry.com/jdk/jdk:Mul registry.com/jdk/jdk:arm registry.com/jdk/jdk:amd

Therefore, the only applicable scenarios for using buildctl build --opt platform=linux/amd64,linux/arm64 directly are as follows:

FROM centos
RUN yum install -y java

Directly building a manifest by marking multiple platform architectures relies heavily on the fact that the files introduced in the dockerfile themselves do not differentiate between architectures or the installation commands themselves can differentiate based on different base images.
However, I have encountered inconsistent component versions provided by basic images under different architectures when using yum to install components.
For example, the libreoffice version provided by amd-centos7 is higher than that of arm-centos7, which leads to fatal differences in some usage scenarios.
Therefore, we had to use dockerfiles of different architectures to introduce installation package files that adapt to the respective architectures into the images. Finally, we merged these images into one manifest.

I think the buildkit should have such capabilities, otherwise I can't give up using docker.