docker-bake.json D and Nix generators

README.md

docker-bake.json generators in various languages

D

Requirements

• dmd >= 2.089.0

How to run

Set the following environment variables:

• REGISTRY_URL
• SERVICE_NAMESPACE - optional, defaults to service
• IMAGE_TAG - optional, defaults to latest
• DEPS_IMAGE_TAG - optional, defaults to latest

Mark docker_bake.d as execuable and then simply run it on Posix:

./docker_bake.d

Nix

Requirements

• Nix >= 2.4 with experimetnal CLI options enabled (it may work otherwise, but I haven't tested)

How to run

Use nix eval to evaluate the Nix expression. Since the expression is a function we need to specify how to call it, but to do that, we must first import it. The function parameters are passed as a single attribute set parameter containing:

{ tag ? "latest"
 ,depsTag ? "dev"
 ,registryUrl
 ,serviceNamespace ? "service"
}

nix eval --raw --impure \
    --expr '(import ./scripts/docker-bake.nix) { registryUrl = "my-registry"; }' \
    | jq

docker-bake.nix

{ tag ? "latest"
 ,depsTag ? "dev"
 ,registryUrl
 ,serviceNamespace ? "service"
}:
let
  result = builtins.toJSON {
    group = { default = { targets = ["emitter" "listener" "seed"]; }; };
    target = {
      seed = makeTarget { targetName = "seed"; };
      listener = makeTarget { targetName = "listener"; };
      emitter = makeTarget { targetName = "emitter"; };
      dependencies = makeTarget { targetName = "dependencies"; useDepsCache = false; };
    };
  };

  makeTarget = { targetName, local ? false, useDepsCache ? true }: {
    cache-from = [
      (makeCacheUrl { inherit targetName; } )
    ] ++ (if useDepsCache
      then [ (makeCacheUrl { targetName = "dependencies"; urlTag = depsTag; }) ]
      else []
    );
    cache-to = [ (makeCacheUrl { inherit targetName; }) ];
    context = ".";
    dockerfile = "Dockerfile";
    labels = { name = "${serviceNamespace}-${targetName}"; };
    output = [ "type=${if local then "Docker" else "registry"}" ];
    platforms = [ "linux/amd64" ];
    tags = [ "${registryUrl}/${targetName}:latest" ];
    target = targetName;
  };

  makeCacheUrl = { targetName, urlTag? tag }:
    "type=registry,ref=${registryUrl}/${targetName}-cache:${urlTag}";
in
result

docker_bake.d

#!/usr/bin/env -S dmd -preview=shortenedMethods -run
import std.format : fmt = format;
import std.json : J = JSONValue, JSONOptions;
import std.process : environment;
import std.stdio : writeln;

string tag() => environment.get("IMAGE_TAG", "latest");
string depsTag() => environment.get("DEPS_IMAGE_TAG", "latest");
string registryUrl() => environment.get("REGISTRY_URL");
string serviceNamespace() => environment.get("SERVICE_NAMESPACE", "service");

void main(string[] args) =>
    [
        "group":
        [
            "default" : [ "targets": ["emitter", "listener", "seed"] ].J
        ],
        "target":
        [
            "emitter": makeTarget("emitter"),
            "listener": makeTarget("listener"),
            "seed": makeTarget("seed"),
            "dependencies": makeTarget("dependencies", false)
        ]
    ].J.toPrettyString(JSONOptions.doNotEscapeSlashes).writeln;

J makeTarget(string targetName, bool depsCache = true, bool local = false) =>
    [
        "cache-from": J(
            [ makeCacheUrl(targetName) ] ~
            (depsCache ?  [ makeCacheUrl("dependencies", depsTag) ] : [])
        ),
        "cache-to": [ makeCacheUrl(targetName) ].J,
        "context": ".".J,
        "dockerfile": "Dockerfile".J,
        "labels": [ "name": "%s-%s".fmt(serviceNamespace, targetName) ].J,
        "output": [ local ? "type=Docker" : "type=registry" ].J,
        "platforms": [ "linux/amd64" ].J,
        "tags": [ "%s/%s:%s".fmt(registryUrl, targetName, tag) ].J,
        "target": targetName.J,
    ].J;

string makeCacheUrl(string targetName, string urlTag = "latest") =>
    "type=registry,ref=%s/%s-cache:%s".fmt(registryUrl, targetName, urlTag);