kubecfg

No need to build it, there's already kubecfg: https://github.com/bitnami/kubecfg

Helm is probably the worst influence I've experienced on the kubernetes ecosystem. It takes something that could have been really good (metaconfig) and makes it illegable, complex, and impossible to debug. Kustomize, too, doesn't get at the root of all the needs I've found myself having. A metaconfig language like Jsonnet, Dhall, or Cuelang seems to be where it's at. If you're using jsonnet I can also highly recommend kubecfg [0] as it's a tool that "just works" and is built at the perfect level of abstraction: "just give me something and I'll find all the kubernetes objects inside of it". It's remarkably simple and forgiving and it makes it possible to describe even the most complex application configs + kube configs in a single language. You can also take it a step further and describe your CI stages (pre-merge, release, builds, etc), k

Super cool to see these sorts of tools. They're great for learning the kube API. For production-y things however, some meta-config language that allows deterministic templateing would be a huge improvement. It allows you to make sweeping/uniform infrastructure changes from a single library or tool change. Kubecfg is a good example of the basics one could implement [0] although it's examples aren't as fully fledged and organized as they could be. [0] - https://github.com/bitnami/kubecfg/blob/master/examples/gues...

I've been using kubecfg [1] with kube.libsonnet [2]. I don't like Tanka as it imposes a given directory structure on me via scaffolding - which is a big no-no for the way I organize projects (I value very unopinionated tools in this regard). I also couldn't get into the ksonnet style of mixins/arguments, as it takes away the ease of overriding underlying Kubernetes structures. [1] - https://github.com/bitnami/kubecfg [2] - https://github.com/bitnami-labs/kube-libsonnet

Highly recommend trying Jsonnet (via https://github.com/bitnami/kubecfg and https://github.com/bitnami-labs/kube-libsonnet) as an alternative. It makes writing Kubernetes manifests much more expressive and integrates better with Git/VCS based workflows. Another language like Dhall or CUE might also work, but I'm not aware of a kubecfg equivalent for them. Jsonnet in general is a pretty damn good configuration language, not only for Kubernetes. And much more powerful than HCL.

Author here. The closest thing to borgcfg in Kubernetes would be kubecfg [0]. It is based on jsonnet, the open source equivalent to GCL. The official blessed solution right now would be kustomize [1] since it is directly integrated into kubectl. I categorize both in the article with my evaluation as solutions. [0] https://github.com/bitnami/kubecfg [1] https://kustomize.io/

I left the company half a decade ago. Just to be clear I actually loved borgcfg, just shared a war story. I'm happy to hear that the tooling improved. I'm unsurprised to hear that many still have mixed feelings towards GCL and ecosystem. FWIW I'm the current maintainer of https://github.com/bitnami/kubecfg whose name is shameless xoogler bait.

All valid points. Fwiw, in https://github.com/bitnami/kubecfg we have added a native functions for yaml.

The way I've saved myself from YAML insanity in k8s is by using kubecfg [1] and kube.libsonnet [2]. I can now build abstractions that work for my particular deployments and never have to worry about extraneous verbosity in day-to-day operations. [1] - https://github.com/bitnami/kubecfg [2] https://github.com/bitnami-labs/kube-libsonnet/blob/master/k...

(shameless plug) The missing piece to turn it into borgcfg: https://github.com/bitnami/kubecfg

I found https://jsonnet.org/ to fix several issues with the Borg configuration language. https://github.com/ksonnet/kubecfg is an attempt to reboot the borgcfg experience with k8s + jsonnet

There's also Kubecfg [1], which uses Jsonnet, but has a much smaller surface area than Ksonnet. [1] https://github.com/ksonnet/kubecfg

I wrote kubecfg as an unashamed imitation of borgcfg, because for all that we like to complain - borgcfg + GCL + git works extraordinarily well. Kubecfg uses jsonnet, which is similarly openly inspired by GCL (but with some important changes). https://jsonnet.org/ https://github.com/ksonnet/kubecfg Example real-world usage: https://github.com/anguslees/k8s-home

Here is one of those: https://github.com/ksonnet/kubecfg

If you (and others on this sub-thread) like managing kubernetes through version control, I humbly suggest trying out the ksonnet/kubecfg toolchain (https://github.com/ksonnet/kubecfg and the closely related ksonnet/ksonnet-lib repo - Disclaimer: I'm one of the contributors). Helm is nice, but (imo, and as some of the comments here are also pointing out) oriented more towards consuming 3rd-party pre-built charts from some sort of centralised marketplace/repo. (This is an important use case, and yes I know it is certainly possible to use helm to manage your own internal software too.)