Build all of your Docker images concurrently from a file with bake
Tags: docker, devops
Published: 2023-02-03 12:20:46

---
title: Build all of your Docker images concurrently from a file with bake
published: true
description: 
tags: #docker #devops
cover_image: https://depot.dev/images/banner/depot-bake.webp
canonical_url: https://depot.dev/blog/buildx-bake-with-depot
---
The ability to build multiple Docker images from a single file is now available in our latest `depot` CLI version. With the `depot bake` command, you can now build multiple images from a single HCL, JSON, or Docker Compose file. It's a fantastic way to build all the images related to your application with a single build request to Depot.

## What is `bake`?

In a nutshell, `bake` is a high-level build command that allows you to build multiple images from a single file via BuildKit. The `bake` command allows you to issue a single build request with the file containing the image definitions to be built. All of the images get built concurrently against a single BuildKit builder.

With Depot, we are orchestrating BuildKit builders for every build you route to us. So a builder and its persistent cache are spawned for each architecture you request in a build. But a single Depot builder (i.e., a project) can handle multiple builds concurrently.

## Build multiple images concurrently

Before `bake` was supported, you would often need to run multiple `depot build` commands to build multiple images with a single builder. A lot of our users have reached for a `Makefile` to do this:

```make
build:
  depot build --project 1234567890 -f Dockerfile.app
  depot build --project 1234567890 -f Dockerfile.db
  depot build --project 1234567890 -f Dockerfile.cron
```

But this results in the images building serially. First, build the app image, then the DB, and finally, the cron image. It works, but you have to issue a separate build request for each image you want to build.

With `bake`, you can build all these images concurrently with a single build request. To do it, you define a file that contains how all the images should be built; it can be written in an HCL, JSON, or Docker Compose file. Here is an example of a `docker-bake.hcl` file that produces the same images as the `Makefile` above:

```hcl
group "default" {
  targets = ["original", "db", "cron"]
}

target "app" {
  dockerfile = "Dockerfile.app"
  platforms = ["linux/amd64", "linux/arm64"]
  tags = ["repo/app:test"]
}

target "db" {
  dockerfile = "Dockerfile.db"
  platforms = ["linux/amd64", "linux/arm64"]
  tags = ["repo/db:test"]
}

target "cron" {
  dockerfile = "Dockerfile.cron"
  platforms = ["linux/amd64", "linux/arm64"]
  tags = ["repo/cron:test"]
}
```

The entire build definition from the `Makefile` above is now contained in a single file. Bake files can specify all of the parameters you would pass to an image build, notice how the file above is using the `platforms` and `tags` parameters, much like `--platform` and `--tag` when running `depot build`.

With this file, you can now run `depot bake` to build all the images in the file:

```bash
depot bake --project 1234567890 -f docker-bake.hcl
```

What you see in the output is multiple images being built concurrently. So, for example, you can see that the `app` image is being made for both `linux/amd64` and `linux/arm64` at the same time as the `db` and `cron` images are being built for both architectures.

```bash
=> [cron linux/arm64 2/3] WORKDIR /app                                                                                                                                                                                                                                                            11.7s
=> [cron linux/amd64 2/3] WORKDIR /app                                                                                                                                                                                                                                                            12.5s
=> [app linux/arm64 build 2/6] WORKDIR /app                                                                                                                                                                                                                                                        6.2s
=> [app linux/amd64 build 2/6] WORKDIR /app                                                                                                                                                                                                                                                        6.6s
=> [app linux/arm64 build 3/6] COPY package.json yarn.lock tsconfig.json ./                                                                                                                                                                                                                        0.0s
=> [db linux/arm64 3/3] RUN echo "postgres build"                                                                                                                                                                                                                                                  0.2s
=> [app linux/arm64 build 4/6] COPY src/ ./src/                                                                                                                                                                                                                                                    0.0s
=> [app linux/arm64 build 5/6] RUN yarn install --immutable                                                                                                                                                                                                                                        9.3s
=> [app linux/amd64 build 3/6] COPY package.json yarn.lock tsconfig.json ./                                                                                                                                                                                                                        0.1s
=> [db linux/amd64 3/3] RUN echo "postgres build"                                                                                                                                                                                                                                                  0.2s
=> [app linux/amd64 build 4/6] COPY src/ ./src/                                                                                                                                                                                                                                                    0.0s
=> [app linux/amd64 build 5/6] RUN yarn install --immutable                                                                                                                                                                                                                                        9.5s
=> [app linux/arm64 build 6/6] RUN yarn build                                                                                                                                                                                                                                                      4.2s
=> [app linux/amd64 build 6/6] RUN yarn build                                                                                                                                                                                                                                                      4.4s
=> [app linux/arm64 stage-1 3/5] COPY --from=build /app/node_modules /app/node_modules                                                                                                                                                                                                             1.6s
```

## `depot/bake-action` GitHub Action

In addition to the `depot bake` command, we released [`depot/bake-action`](https://github.com/depot/bake-action) GitHub Action that implements the same inputs and outputs as the `docker/bake-action`.

Like our [`depot/build-push-action`](https://github.com/depot/build-push-action), you can use GitHub's OpenID Connect tokens via a trust relationship, so your builds can authenticate with Depot projects without needing any static access tokens. Here is an example GitHub Action workflow that builds images from a `docker-bake.hcl` file:

```yaml
name: Run Depot bake
on: push

permissions:
  id-token: write
  contents: read

jobs:
  build:
    name: Build
    runs-on: ubuntu-20.04
    steps:
      - name: Checkout repo
        uses: actions/checkout@v3

      - uses: depot/setup-action@v1

      - name: Bake Docker images
        uses: depot/bake-action@v1
        with:
          project: 1234567890
          file: docker-bake.hcl
```

## Conclusion

Building multiple images via `depot bake` is a great way to speed up your image builds even more. With `bake`, you can leverage the ability of BuildKit to build multiple images concurrently and deduplicate work across multiple images specified in a single build request.

Define all the images that compose your application in a single HCL, JSON, or Docker Compose file and run `depot bake` to build them all at once. No more waiting for each image to build one at a time. Instead, you can build them all concurrently on the same builder.

For those of you leveraging GitHub Actions, you can use the [`depot/bake-action`](https://github.com/depot/bake-action) to build images from your file inside your existing Actions workflows. Just swap in `depot/bake-action` for `docker/bake-action`, and you're good to go.

If you're not using Depot, we offer a 14-day free trial to let you try things out in your existing workflows to see if we can make your image builds faster. We are the only remote container build service that offers native multi-platform image support, and we make caching a breeze because it's automatically persisted for you across builds. These two features usually make image builds 15x faster in CI environments.

Sign up today for a 14-day free trial and swap `docker build` for `depot build` to get instantly faster builds: https://depot.dev/sign-up.