Crafting container images without Dockerfiles

1. rules_docker

   1 8 1,058 0.0 Starlark

   Discontinued Rules for building and handling Docker images with Bazel

   

   My company uses Bazel's rules docker to build our images: https://github.com/bazelbuild/rules_docker

   They're pretty great and have a lot of the caching and parallelism benefits mentioned in the post for free out of the box, along with determinism (which Docker files don't have because you can run arbitrary shell commands). Our backend stack is also built with Bazel so we get a nice tight integration to build our images that is pretty straightforward.

   We've also built some nice tooling around this to automatically put our maven dependencies into different layers using Bazel query and buildozer. Since maven deps don't change often we get a lot of nice caching advantages.

2. InfluxDB

   www.influxdata.com featured

   InfluxDB – Built for High-Performance Time Series Workloads. InfluxDB 3 OSS is now GA. Transform, enrich, and act on time series data directly in the database. Automate critical tasks and eliminate the need to move data externally. Download now.

   

3. buildah

   2 30 7,834 9.6 Go

   A tool that facilitates building OCI images.

   

4. tiles

   3 1 - -

   Sure. Putting a simple binary in a container: https://gitlab.com/kevincox/tiles/-/blob/a2b907eab7a84989c94.... This is the trivial case where you just stick the main executable in the command string. Nix will automatically include the dependencies.

   The GitLab CI example is a bit more complex. It requires some commands that are unused by the image and some config files: https://gitlab.com/kevincox/nix-ci/-/blob/efe6f4deedc50c2474...

5. nix-ci

   4 1 - -

   Sure. Putting a simple binary in a container: https://gitlab.com/kevincox/tiles/-/blob/a2b907eab7a84989c94.... This is the trivial case where you just stick the main executable in the command string. Nix will automatically include the dependencies.

   The GitLab CI example is a bit more complex. It requires some commands that are unused by the image and some config files: https://gitlab.com/kevincox/nix-ci/-/blob/efe6f4deedc50c2474...

6. rules_nixpkgs

   5 5 326 8.9 Starlark

   Rules for importing Nixpkgs packages into Bazel.

   

7. apko

   6 17 1,350 9.6 Go

   Build OCI images from APK packages directly without Dockerfile

   

8. go-containerregistry

   7 18 3,349 5.3 Go

   Go library and CLIs for working with container registries

   

9. SaaSHub

   www.saashub.com featured

   SaaSHub - Software Alternatives and Reviews. SaaSHub helps you find the best software and product alternatives

   

10. pack

    8 55 2,714 9.0 Go

    CLI for building apps using Cloud Native Buildpacks

    

    Although Dockerfiles have the benefit of migrating existing workloads to containers without having to update your toolchain, I definitely prefer the container-first workflow. Cloud Native [Buildpacks](https://buildpacks.io/) are a CNCF incubating project but were proven at Heroku. Buildpacks support common languages, but working on a Go project I've also had a great experience with [ko](https://ko.build/). Free yourself from Dockerfile!

11. conda-docker

    9 1 59 0.0 Python

    Create minimal docker images from conda environments

    

    For creating images without docker from conda/mamba environments, there's also the existing `conda-docker` tool https://github.com/conda-incubator/conda-docker.

12. nixery

    10 18 1,878 3.4 Go

    Container registry which transparently builds images using the Nix package manager. Canonical repository is https://cs.tvl.fyi/depot/-/tree/tools/nixery

    

    I built a service for doing this ad-hoc via image names a few years ago and it enjoys some popularity with CI & debugging use-cases: https://nixery.dev/

13. manifest-tool

    11 2 795 7.8 Go

    Command line tool to create and query container image manifest list/indexes

    

14. dinker

    12 2 12 10.0 Go

    Dinker, dinky Docker images

    

    (Self plug) I had the same thoughts as the author, and made this: https://github.com/andrewbaxter/dinker . Like stated in the article, if you're doing rust or go all you want is to dump the binary in the image. There's no reason to do the build inside the docker vm in that case, and it's super fast, and only uses dumb filesystem access - no daemons like docker, weird wip container managers like buildah, etc.

15. mkosi

    13 19 1,407 9.9 Python

    💽 Build Bespoke OS Images

    

    System's mkosi is worth checking out too: https://github.com/systemd/mkosi I don't think it generates docker/OCI images directly, but it definitely can generate a tarball of the final image contents and then crane of a similar tool could package it up into an appropriate image. For just docker usage it's probably overkill, the main advantage would be it can build other image types like adding a kernel and init to be a fully bootable iso of VM image.

16. kubevirt

    14 53 6,033 10.0 Go

    Kubernetes Virtualization API and runtime in order to define and manage virtual machines.

    

    It can, kubevirt is a project for running VMs https://kubevirt.io/ and there have been more esoteric things like WASM (https://github.com/krustlet/krustlet).

17. krustlet

    15 21 3,584 3.1 Rust

    Kubernetes Rust Kubelet

    

    It can, kubevirt is a project for running VMs https://kubevirt.io/ and there have been more esoteric things like WASM (https://github.com/krustlet/krustlet).

18. bazel-nix-example

    16 3 27 0.0 Starlark

    

    I put together an example that mixes Nix and Bazel a couple of years ago: https://github.com/jvolkman/bazel-nix-example

    Nix is used to build a base Docker image, and Bazel builds layers on top.

19. cargo-chef

    17 19 2,090 6.1 Rust

    A cargo-subcommand to speed up Rust Docker builds using Docker layer caching.

    

    If this ends up being a cleaner/easier way to having to workaround super expensive rebuilds for Rust given cache + deps compared to this https://github.com/LukeMathWalker/cargo-chef , reading this thread will have been a huge win for me (and hopefully others).

    Whether introducing Bazel is easier/worth it, subjective I guess.

20. sdk-container-builds

    18 7 190 5.2 C#

    Libraries and build tooling to create container images from .NET projects using MSBuild

    

    We've been baking this functionality directly into the .NET SDK for a couple releases now: https://github.com/dotnet/sdk-container-builds

    It's really nice to derive mostly-complete container images from information your build system already has available, and the speed/UX benefits are great too!

21. crane

    19 15 1,061 9.1 Nix

    A Nix library for building cargo projects. Never build twice thanks to incremental artifact caching.

    

    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.

22. nix2container

    20 10 623 4.6 Go

    An archive-less dockerTools.buildImage implementation

    

    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.

23. SaaSHub

    www.saashub.com featured

    SaaSHub - Software Alternatives and Reviews. SaaSHub helps you find the best software and product alternatives

    

Suggest a related project