Kubernetes Made Me Do It: Why I Traded Bash For GoLang

Linux -> Bash -> Golang <- Kubernetes... Naturally

I’ve always been a Linux > Windows guy. You just can’t beat the terminal.

Working closely with the command line, I’ve run the command utilities countless times. So when it came time to choose a scripting language, the only logical option was Bash. I’ve been scripting in Bash for a while now, not a fanatic, but I just got it for a long time. It was the native tongue for automating all those little sysadmin tasks, gluing together grep, awk, sed, and curl into something useful. Need to parse some logs quickly? Backup a directory? Automate a deployment step? Bash was my co-D (good friend).

But you know how it is. Those Bash scripts start small, then they grow. And then they grow some more. Suddenly you’re fighting with obscure quoting rules, trying to manage complex state, or wishing for decent error handling that doesn’t involve set -e and a dua (a prayer). Performance for anything non-trivial can also start to be … LONG. Bash is sweet for what it is, but there comes a point where you need something more robust, something that scales better with complexity without losing that direct, system-level feel.

That’s where we talk about Go (or Golang, if you prefer). I started seeing it pop up everywhere, especially in the tools I was beginning to lean on heavily.

The syntax felt clean, way more straightforward than some alternatives for what I wanted to do, and the C-like roots resonated with my Linux background. Static binaries? Yes, please! Just like my script.sh executables! Concurrency that’s built-in and easy to reason about? Banging. It felt like it was designed by people who understood the kinds of problems I was trying to solve, building solid, performant command-line tools and system services.

As I dived deeper into containerisation and orchestration, guess what kept staring me in the face? Go. Kubernetes itself is written in Go. Docker? Go. Helm? Go. Prometheus? Go. Most of the Cloud Native Computing Foundation (CNCF) landscape seemed to be built on it. Suddenly, learning Go wasn’t just about writing better, faster scripts; it was about understanding the very fabric of the modern infrastructure I was increasingly working with.

It’s one thing to use kubectl to interact with your cluster. It’s another to peek under the hood, to understand how the API server works, or to even think about writing your own custom controllers or operators to extend Kubernetes functionality. That journey from "Linux command-line guy" to "Bash scripter" naturally evolved into "Go developer" because Go is the language of Kubernetes and the cloud-native ecosystem.

Now, when I need to build a tool that talks to the Kubernetes API, or a specialised service that runs within the cluster, Go is the obvious choice. It feels like I’m still close to the metal, much like with Bash, but with the power, type safety, and ecosystem to build some seriously robust and complex applications. It’s like graduating from that trusty multi-tool to a full, professional-grade toolkit, perfectly suited for the intricate machinery of systems like Kubernetes.

So, that’s been my path. From the raw power of the Linux command line, through to Bash, to the robust world of Go, driven largely by the gravitational pull of Kubernetes. What’s your journey been like in this space? Still all-in on Bash, or have you found other languages indispensable for your Kubernetes adventures?

Let me know if you enjoy these sorts of reads and what you’d like to see more from!