# Build all of your Docker images concurrently from a file with bake (https://depot.dev/blog/buildx-bake-with-depot) > By Kyle Galbraith (CEO & Co-founder of Depot) > Published 2023-01-30 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 Docker 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 Docker 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 ``` ### Using bake with Docker Compose You can also use Docker Compose files with `depot bake`. This allows you to build multiple images from a single compose file. Here is an example `docker-compose.yml` file that builds the same images as the `docker-bake.hcl` file above: ```yaml services: app: build: dockerfile: Dockerfile.app platforms: - linux/amd64 - linux/arm64 db: build: dockerfile: Dockerfile.db platforms: - linux/amd64 - linux/arm64 cron: build: dockerfile: Dockerfile.cron platforms: - linux/amd64 - linux/arm64 ``` This allows you to define a single file that contains multiple Docker images with multiple Dockerfiles and build them all concurrently with a single `depot bake` command. ## `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 BuildKit's ability 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 free tier 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 our free trial and swap `docker build` for `depot build` to get instantly faster builds: [https://depot.dev/sign-up](https://depot.dev/sign-up). ## For AI Agents The full site index is at [llms.txt](https://depot.dev/llms.txt). Append `.md` to any documentation, blog, changelog, or customer URL to fetch its markdown source directly.