8 ms·
BuildKit: Docker's Hidden Gem That Can Build Almost Anything
- whalesalad 8mo agoFolks, please fix your AI generated ascii artwork that is way out of alignment. This is becoming so prevalent - instant AI tell.
- craftkiller 8mo agoAre you on a phone? I loaded the article with both my phone and laptop. The ascii diagram was thoroughly distorted on my phone but it looked fine on my laptop.
- whalesalad 8mo agoFirefox on a 27" display. Could be the font being used to render.
- antonvs 8mo agoThe only ASCII image I see on that page is actually a PNG: https://tuananh.net/img/buildkit-llb.png https://tuananh.net/img/buildkit-llb.png Maybe the page was changed? If you're just talking about the gaps between lines, that's just the line height in whatever source was used to render the image, which doesn't say much about AI either way.
- tuananh 8mo agolooks fine to me but since it messed up for some so i replace it with png
- unshavedyak 8mo agoI imagine it's not the AI then, but the site font/css/something. Seeing as it looks fine for me (Brave, Linux).
- seneca 8mo agoI found it more jarring that they chose to use both Excalidraw and ascii art. What a strange choice.
- tuananh 8mo agothe hugo theme requires an image thumbnail. i just find one and use it :D
- scuff3d 8mo agoThe "This is the key insight -" or "x is where it gets practical -", are dead give aways too. If I wanted an LLMs explanation of how it works, I can ask an LLM. When I see articles like this I'm expecting an actual human expert
- slekker 8mo agoThis one too: "It’s a proven pattern."
- croes 8mo agoAnd waste time and energy again to get a similar result?
- scuff3d 8mo agoAn article written by an expert is nothing like this. You might be able to get something similar out of an LLM but it's gonna take a lot more effort then was out into this.
- moochmooch 8mo agounfortunately, make is more well written software. I think ultimately Dockerfile was a failed iteration of Makefile. YAML & Dockerfile are poor interfaces for these types of applications. The code first options are quite good these days, but you can get so far with make & other legacy tooling. Docker feels like a company looking to sell enterprise software first and foremost, not move the industry standard forward great article tho!
- craftkiller 8mo agoAlong similar lines, when I was reading the article I was thinking "this just sounds like a slightly worse version of nix". Nix has the whole content addressed build DAG with caching, the intermediate language, and the ability to produce arbitrary outputs, but it is functional (100% of the inputs must be accounted for in the hashes/lockfile, as opposed to Docker where you can run commands like `apk add firefox` which is pulling data from outside sources that can change from day to day, so two docker builds can end up with the same hash but different output, making it _not_ reproducible like the article falsely claims). Edit: The claim about the hash being the same is incorrect, but an identical Dockerfile can produce different outputs on different machines/days whereas nix will always produce the same output for a given input.
- jasonpeacock 8mo agoYou can network-jail your builds to prevent pulling from external repos and force the build environment to define/capture its inputs.
- verdverm 8mo agojust watch out for built at timestamps
- ricardobeat 8mo ago> so two docker builds can end up with the same hash but different output The cache key includes the state of the filesystem so I don’t think that would ever be true. Regardless, the purpose of the tool is to generate [layer] images to be reused, exactly to avoid the pitfalls of reproducible builds, isn’t it? In the context of the article, what makes builds reproducible is the shared cache.
- bmitch3020 8mo agoI don't use buildkit for artifacts, but I do like to output images to an OCI Layout so that I can finish some local checks and updates before pushing the image to a registry. But the real hidden power of buildkit is the ability to swap out the Dockerfile parser. If you want to see that in action, look at this Dockerfile (yes, that's yaml) used for one of their hardened images: https://github.com/docker-hardened-images/catalog/blob/main/image/redis/debian-13/8.2.yaml https://github.com/docker-hardened-images/catalog/blob/main/...
- tuananh 8mo agoi did include a repo example on how to create custom frontend as well https://github.com/tuananh/apkbuild https://github.com/tuananh/apkbuild
- kylegalbraith 8mo agoI agree on both fronts! BuildKit frontends are not very well known but can be very powerful if you know how they work and how BuildKit transforms them.
- verdverm 8mo agoBuildKit also comes with a lot of pain. Dagger (a set of great interfaces to BuildKit in many languages) is working to remove it. Even their BuildKit maintainers think it's a good idea. BuildKit is very cool tech, but painful to run at volume Fun gotchya in BuildKit direct versus Dockerfiles, is the map iteration you loaded those ENV vars into consistent? No, that's why your cache keeps getting busted. You can't do this in the linear Dockerfile
- kodama-lens 8mo agoI switched our entire container build setup to buildkit. No kaniko, no buildah, no dind. The great part is that you can split buildkitd and the buildctl. Everything runs in its own docker runner. New buildkitd service for every job. Caching only via buildkit native cache export. Output format oci image compressed with zstd. Works pretty great so far, same or faster builds and we now create multi arch images. All on rootless runners by the way
- verdverm 8mo agoThat's pretty cool, rootless would be nice, but more effort than we see in ROI currently. I'm using the Dagger SDK directly, no CLI or modules. Had to recently make it so multiple versions can run on the same host, such that as developers change branches, which may be on different IaC'd versions (we launch on demand), we don't break LTS release branches.
- Orygin 8mo agoThat's my experience too. Coming from single threaded, single concurrent build Kaniko to parallel builds using Buildkit reduced build times by 2 to 3.
- zaphirplane 8mo agoThis is a strange double submission , the one with caps made it ! https://news.ycombinator.com/item?id=47152488 https://news.ycombinator.com/item?id=47152488
- jccx70 8mo ago[dead]
- cyberax 8mo agoBuildkit... It sounds great in theory, but it JustDoesn'tWork(tm). Its caching is plain broken, and the overhead of transmitting the entire build state to the remote computer every time is just busywork for most cases. I switched to Podman+buildah as a result, because it uses the previous dead simple Docker layered build system. If you don't believe me, try to make caching work on Github with multi-stage images. Just have a base image and a couple of other images produced from it and try to use the GHA cache to minimize the amount of pulled data.
- mid-kid 8mo agoHow do you use buildah? with dockerfiles? I find that buildah is sort of unbearably slow when using dockerfiles...
- cyberax 8mo agoIt has a braindead cache checking, I've fixed it locally and I'm cleaning it up for the upstream submission. But otherwise, it's always faster for me than Buildkit.
- hanikesn 8mo agoWhy would you use the horrible GHA cache and not a much more efficient registry based cache?
- cyberax 8mo agoRegistry cache... It's yet one more incomprehensible Buildkit decision. The original Docker builder had a very simple cache system: it computed the layer hash and then checked the registry for its presence. Simple content-addressable caching. Buildkit can NOT do this. Instead, it uses a single image as a dumping ground for the caches. If you have two builders using the same image, they'll step on each other's toes. GHA at least side-steps this. But I tried the registry cache, and it didn't improve anything. So far, I was not able to get caching to work with multi-stage builds at all. There are open issues for that, dating back to 2020.
- 8mo ago
- kylegalbraith 8mo agoAfter building Depot [0] for the past three years, I can say I have a ton of scar tissue from running BuildKit to power our remote container builders for thousands of organizations. It looks and sounds incredibly powerful on paper. But the reality is drastically different. It's a big glob of homegrown thoughts and ideas. Some of them are really slick, like build deduplication. Others are clever and hard to reason about, or in the worst case, terrifying to touch. We had to fork BuildKit very early in our Depot journey. We've fixed a ton of things in it that we hit for our use case. Some of them we tried to upstream early on, but only for it to die on the vine for one reason or another. Today, our container builders are our own version of BuildKit, so we maintain 100% compatibility with the ecosystem. But our implementation is greatly simplified. I hope someday we can open-source that implementation to give back and show what is possible with these ideas applied at scale. [0] https://depot.dev/products/container-builds https://depot.dev/products/container-builds
- skrtskrt 8mo ago> It's a big glob of homegrown thoughts and ideas. Some of them are really slick, like build deduplication. Others are clever and hard to reason about, or in the worst case, terrifying to touch. This is true of packaging and build systems in general. They are often the passion projects of one or a handful of people in an organization - by the time they have active outside development, those idiosyncratic concepts are already ossified. It's really rare to see these sorts of projects decomposed into building blocks even just having code organization that helps a newcomer understand. Despite all the code being out in public, all the important reasoning about why certain things are the way they are is trapped inside a few dev's heads.
- mikepurvis 8mo agoAs someone who has worked in the space for a while and been heavily exposed to nix, bazel, cmake, bake, and other systems, and also been in that "passion project" role, I think what I've found is that these kinds of systems are just plain hard to talk about. Even the common elements like DAGs cause most people's eyes to immediately glaze over. Managers and executives are happy to hear that you made the builds faster or more reliable, so the infra people who care about this kind of thing don't waste time on design docs and instead focus on getting to a minimum prototype that demonstrates those improved metrics. Once you have that, then there's buy-in and the project is made official... but by then the bones have already been set in place, so design documentation ends up focused on the more visible stuff like user interface, storage formats, etc. OTOH, bazel (as blaze) was a very intentionally designed second system at Google, and buildx/buildkit is similarly a rewrite of the container builder for Docker, so both of them should have been pretty free of accidental engineering in their early phases.
- Avamander 8mo agoExcept anything that requires any non-trivial networking or hermetic building.
- matheus-rr 8mo agoThe --mount=type=cache for package managers is genuinely transformative once you figure it out. Before that, every pip install or apt-get in a Dockerfile was either slow (no caching) or fragile (COPY requirements.txt early and pray the layer cache holds). What nobody tells you is that the cache mount is local to the builder daemon. If you're running builds on ephemeral CI instances, those caches are gone every build and you're back to square one. The registry cache backend exists to solve this but it adds enough complexity that most teams give up and just eat the slow builds. The other underrated BuildKit feature is the ssh mount. Being able to forward your SSH agent into a build step without baking keys into layers is the kind of thing that should have been in Docker from day one. The number of production images I've seen with SSH keys accidentally left in intermediate layers is genuinely concerning.
- candiddevmike 8mo agoI hate the nanny state behavior of docker build and not being allowed to modify files/data outside of the build container and cache, like having a NFS mount for sharing data in the build or copying files out of the build. Let me have side effects, I'm a consenting adult and understand the consequences!!!
- amluto 8mo agoThere is something wrong with the industry in which we think that, when a production build requires SSH keys, the problem is that the keys might leak into the build artifact.
- stevenhuang 8mo agoKeys leaking into the build artifact was never the concern. It's about not having the private keys stored unknowingly in intermediate layers of a build container.
- amluto 8mo agoThose intermediate layers are usually part of the artifact. Try exporting an image with docker save and investigate what’s inside. This is all documented in a mostly comprehensible manner in the OCI specs. I’m afraid you’re missing my point, though. A high quality build system takes fixed inputs and produces outputs that are, to the extent possible, only a function of the inputs. If there’s a separate process that downloads the inputs (and preferably makes sure they are bitwise identical to what is expected), fine, but that step should be strictly outside the inputs to the actual thing that produces the release artifact. Think of it as: artifact = build_process(inputs) inputs = fetch(credentials, cache, hashes, etc) Or, even better perhaps: inputs = … assert hash(inputs) == expected (And now, unless you accidentally hash your credentials into the expected hash, you can’t leak credentials into the output!) Once you have commingled it so that it looks like: final output, intermediate layers = monolithic_mess(credentials, cache, etc) Then you completely lose track of which parts are deterministic, what lives in the intermediate layers, where the credentials go, etc. Docker build is not a good build system, and it strongly encourages users to do this the wrong way, and there are many, many things wrong with it, and only one of those things is that the intermediate layers that you might think of as a cache are also exposed as part of the output.
- ltbarcly3 8mo agoBut the problem is it's trash? I've repeatedly tried to do things documented to work that weren't implemented, or where the implementation is buggy. Docker is profoundly bad software.
- selfhosting_sh 8mo ago[flagged]