crate2nix VS nix2container

I'll use nixpkgs' buildRustPackage. There's a few other tools, my favorite being crate2nix, but we'll leave that to a future tutorial.

If you want to iterate with nix instead of cargo, crate2nix and cargo2nix provides more caching and more fine control over your dependencies. I haven't used these two so you would have to decide for yourself. You may also want to try out nocargo for something more experimental.

I'm yet to try it out, but from the blog post, the README and the source it appears that Crane builds all dependencies in one derivation (separately from the main crate). This means that if a dependency gets added, removed or changed, all dependencies of a crate will be rebuilt. This is in contrast with https://github.com/kolloch/crate2nix, which does build every dependency in a separate package, thus you don't need to rebuild other dependencies if you only change a small part of the tree.

Yes, you will have to package it if it's not already in nixpkgs.

The good news is once you learn how, it's basically trivial with crate2nix[0], which can autogenerate nix derivations from rust crates

[0] https://github.com/kolloch/crate2nix

From my quick reading of cargo2nix's webpage yes. https://github.com/kolloch/crate2nix has a workspaces section.

As for your two applications, they're both written in Rust, and I like https://github.com/kolloch/crate2nix as a way to package Rust crates with Nix. BTW, wezterm is already in nixpkgs!

I like the way crate2nix works. I have made a flake template for it here. Sometimes it requires a couple of overrides to fix some misbehaving crates (see https://github.com/balsoft/simple-osd-daemons/blob/master/flake.nix#L29 for an example of such overrides), but otherwise it's fantastic. It doesn't require any hash nonsense, it downloads and builds all the crates separately (unlike naersk or other solutions) so you get all the benefits of Nix (reproducibility and proper caching).

Crate2nix might help: https://github.com/kolloch/crate2nix

No discussion about Nix-built containers is complete with nix2container:

https://github.com/nlewo/nix2container

It is truly magical for handling large, multi-layered containers. Instead of building the container archives themselves and storing them in the nix store, it builds a JSON manifest that is consumed by a lightly patched version of skopeo that streams the layers directly to either your local container engine or the registry.

This means you never rebuild or reupload a container layer that is unchanged.

- Container images are built with https://github.com/nlewo/nix2container instead of Nix's built-in docker tools, because nix2container allows configuration of layers and thus makes it easier to share layers between images and improve layer caching.

As for integrating it into our CI pipeline, this is pretty much CI system agnostic as all you have to do is run `nix build ...` inside the pipeline, generating a `result` directory or file as an artifact that, in the case of nix2container, can be pushed to your container image registry.

dockerTools is the canonical way, but https://github.com/nlewo/nix2container seems to be gaining support as it's faster and doesn't use so much disk space while building.

> The key factor behind our decision was the realization that while Docker images are industry standard, moving around 100s of megabytes of images seems unnecessarily heavy-handed when we just need to synchronize a small change.

I think the culprit is more the GitHub Actions cache than Docker since it seems to be hard to get a clean cache management. I'm not sure about caching Docker image layers, but caching the Nix store with GitHub Actions is pretty complicated (not even sure it's possible): this means we have to download all required Nix store paths on each run, but i consider this is because of a GitHub Action cache limitation.

So, did you consider using another CI, which offers better caching mechanisms?

With a CI able to preserve the Nix store (Hydra[1] or Hercules[2] for instance), I think nix2container (author here) could also fit almost all of your requirements ("composability", reproducibility, isolation) and maybe provide better performances because it is able to split your application into several layers [2][3].

Note i'm pretty sure a lot of Docker CI also allows to efficiently build Docker images.

[1] https://hercules-ci.com/

[2] https://grahamc.com/blog/nix-and-layered-docker-images

[3] https://github.com/nlewo/nix2container/blob/85670cab354f7df6...

FYI, the nix2container [1] project (author here) aims to speedup the standard Nix container workflow (dockerTools.buildImage) by basically skipping the tarball step: it directly streams non already pushed layers.

[1] https://github.com/nlewo/nix2container

To get Rust incremental builds, did you consider using something such as crane https://github.com/ipetkov/crane ?

And regarding OCI images, i built nix2container (https://github.com/nlewo/nix2container) to speed up image build and push times.

For a more modern iteration of that idea, check out https://github.com/nlewo/nix2container

It has all the benefits of OP but produces the images much faster, and with less on-disk usage.

I've been using nix2container[1] for awhile now. It looks like this depends on Docker, have you guys considered removing that dependency? It shouldn't be necessary to create an OCI compliant image with Nix.

[1]: https://github.com/nlewo/nix2container

With https://github.com/nlewo/nix2container, I'm trying to make a more standalone tool. Basically, a Go binary takes a reference graph and produces a JSON file describing a container image. This JSON file is then ingested by a Skopeo fork (it adds a new `transport`) to produce images (to file, registries,...).

Currently, it supports the dockerTools layering algorithm and is designed to work with Guix [1] as well;)

[1] https://github.com/nlewo/nix2container/blob/065e5b108650ee4c...