Bake does not support platform key in docker-compose.yml

[ciaranmcnulty]

Now that compose-spec is used for bake, this is no longer a syntax error, but the flag doesn't seem to be used when building the images

Dockerfile:

FROM mysql

(note mysql does not provide ARM images)

docker-compose.yml:

services:
  database:
    build:
      context: .
    platform: linux/amd64

On an ARM64 machine (M1 Mac)

% docker-compose build                                           
Building database
[+] Building 0.6s (5/5) FINISHED                                                                                                                                                                                                                                                                                        
 => [internal] load build definition from Dockerfile                                                                                                                                                                                                                                                               0.0s
 => => transferring dockerfile: 53B                                                                                                                                                                                                                                                                                0.0s
 => [internal] load .dockerignore                                                                                                                                                                                                                                                                                  0.0s
 => => transferring context: 2B                                                                                                                                                                                                                                                                                    0.0s
 => [internal] load metadata for docker.io/library/mysql:latest                                                                                                                                                                                                                                                    0.6s
 => CACHED [1/1] FROM docker.io/library/mysql@sha256:99e0989e7e3797cfbdb8d51a19d32c8d286dd8862794d01a547651a896bcf00c                                                                                                                                                                                              0.0s
 => exporting to image                                                                                                                                                                                                                                                                                             0.0s
 => => exporting layers                                                                                                                                                                                                                                                                                            0.0s
 => => writing image sha256:9c8cabb8167a46d931af0f0b8646796b55bda249c2a38fcc8284b18a6cd1d4c9                                                                                                                                                                                                                       0.0s
 => => naming to docker.io/library/bake-project-reprod_database  

% docker buildx bake -f docker-compose.yml
[+] Building 0.7s (3/3) FINISHED                                                                                                                                                                                                                                                                                        
 => [internal] load build definition from Dockerfile                                                                                                                                                                                                                                                               0.0s
 => => transferring dockerfile: 31B                                                                                                                                                                                                                                                                                0.0s
 => [internal] load .dockerignore                                                                                                                                                                                                                                                                                  0.0s
 => => transferring context: 2B                                                                                                                                                                                                                                                                                    0.0s
 => ERROR [internal] load metadata for docker.io/library/mysql:latest                                                                                                                                                                                                                                              0.6s
------
 > [internal] load metadata for docker.io/library/mysql:latest:
------
error: failed to solve: failed to solve with frontend dockerfile.v0: failed to create LLB definition: no match for platform in manifest sha256:99e0989e7e3797cfbdb8d51a19d32c8d286dd8862794d01a547651a896bcf00c: not found

[ciaranmcnulty]

Of course, this works

docker-bake.hcl:

group "default" {
  targets = ["database"]
}

target "database" {
  platforms = ["linux/amd64"]
}

 % docker buildx bake -f docker-bake.hcl
[+] Building 1.5s (6/6) FINISHED                                                                                                                                                                                                                                                                                        
 => [internal] load build definition from Dockerfile                                                                                                                                                                                                                                                               0.0s
 => => transferring dockerfile: 31B                                                                                                                                                                                                                                                                                0.0s
 => [internal] load .dockerignore                                                                                                                                                                                                                                                                                  0.0s
 => => transferring context: 2B                                                                                                                                                                                                                                                                                    0.0s
 => [internal] load metadata for docker.io/library/mysql:latest                                                                                                                                                                                                                                                    1.4s
 => [auth] library/mysql:pull token for registry-1.docker.io                                                                                                                                                                                                                                                       0.0s
 => CACHED [1/1] FROM docker.io/library/mysql@sha256:99e0989e7e3797cfbdb8d51a19d32c8d286dd8862794d01a547651a896bcf00c                                                                                                                                                                                              0.0s
 => exporting to image                                                                                                                                                                                                                                                                                             0.0s
 => => exporting layers                                                                                                                                                                                                                                                                                            0.0s
 => => writing image sha256:9c8cabb8167a46d931af0f0b8646796b55bda249c2a38fcc8284b18a6cd1d4c9    

[ciaranmcnulty]

It looks like x-bake from #721 has a platforms field, but it would be good to support the existing (singular) Yaml one too

[tonistiigi]

There is no platform field under build definition in compose yaml afaik. The service level field defines which platform to run and is not an array type.

[ciaranmcnulty]

You’re right platform is at the service level, (as in my example above) but it’s used by compose to determine the build platform nevertheless

[tonistiigi]

but it’s used by compose to determine the build platform nevertheless

That does not make much sense. The point of the runtime field is to "filter", but if you discard everything else on the build there is nothing to filter. Plus the only case to set it (as the type is wrong and not an array) is to build for a non-native platform and then your runtime platform is wrong as you should never run emulated arch.

[ciaranmcnulty]

It may not make much sense but that's the docker-compose behaviour AFAIK - compose only ever builds a single image, never multi-arch and it can be overridden using that platform field if you need non-native (in this case because the base image isn't available natively).

you should never run emulated arch

On more than one project I'm working on using mysql-based containers for the dev environment, we've added the platform key to trigger QEMU-based emulation on M1 Macs

If you're going for the experience that 'you can bake your existing docker-compose.yml' this will probably become more common as the chipsets diversify.

[crazy-max]

@ciaranmcnulty In one case we use the image field in bake to populate tags but it's part of the compose specification for build. platform only defines the target platform on which the containers of this service will run.

[ciaranmcnulty]

In that link:

MUST use this attribute when declared to determine which version of the image will be pulled and/or on which platform the service’s build will be performed.

I'm not sure how MUST combines with and/or ;)

EDIT: I raised an issue about the ambiguity compose-spec/compose-spec#197

[tonistiigi]

On more than one project I'm working on using mysql-based containers for the dev environment, we've added the platform key to trigger QEMU-based emulation on M1 Macs

If you are doing this because mysql image does not have an arm variant then you shouldn't (and docker should warn you about it, not sure if compose does). Switch to mysql/mysql-server or mariadb

[ciaranmcnulty]

It doesn’t warn if the platform flag is set

[tonistiigi]

It doesn’t warn if the platform flag is set

docker or compose?

» docker run -it --rm mysql                                                                                                                                                                          
WARNING: The requested image's platform (linux/amd64) does not match the detected host platform (linux/arm64/v8) and no specific platform was requested

[ciaranmcnulty]

Docker doesn't warn if the platform flag is set

docker run -it --rm mysql    

Docker compose doesn't warn if the platform flag is set:

services:
  mysql:
    image: mysql
    platform: linux/amd64

In neither case is the user prompted they're doing something incorrect.

The case I'm hoping you'll support is the migration one:

a) I'm using docker-compose with a single-arch container
b) I add platform to make everything work
c) One day I decide to try bake instead

For my use-case I'm happy when x-bake comes into a release I can have some duplication

  myservice:
    platform: "linux-amd64" # runtime concern
    build:
      x-bake:
        platforms: ["linux-amd64"] # build-time concern

[ciaranmcnulty]

Just wanted to note this caught me out again today. I think it would make sense to normalise the platform if one isn't specified in x-bake, so that:

services:
  myservice:
    build:
      context: .
    platform: linux/arm64

would normalise to

  "target": {
    "myservice": {
      "context": ".",
      "dockerfile": "Dockerfile",
      "platforms": [
        "linux/arm64"
      ]
    }
  }

IMHO it's very analogous to how image does double-duty as a build and runtime flag