Kubernetes: A Journey Through Complexity, Curiosity, and Growth

Let’s be honest: Kubernetes is a beast.

Starting with Kubernetes feels a bit like being handed a Rubik’s Cube without instructions and told, “By the way, this controls your entire infrastructure.” But here’s the twist—it’s not just frustrating; it’s thrilling. My internship at Elastisys has been a wild ride through Kubernetes’ labyrinth of pods, deployments, and YAML files. Mistakes? Plenty. Learning? Even more. And isn’t that what makes the journey worthwhile?

Stepping into the World of Kubernetes

When I first encountered terms like kubectl, Helm, and Ingress, they might as well have been spells from a fantasy novel. My initial days were spent learning how to deploy applications, manage namespaces, and wrestle YAML manifests that sometimes had minds of their own. But Kubernetes isn’t just about doing—it’s about understanding. Why does a pod fail? Why is that ConfigMap not behaving? It’s a system that forces you to think, not just act.

One of my biggest lessons? Kubernetes thrives on the tools around it. Helm made managing complex deployments feel almost magical. Observability tools like Grafana and Prometheus transformed opaque clusters into visual stories of performance. And ArgoCD—oh, what a revelation! From managing continuous deployments to troubleshooting sync errors, ArgoCD was both a challenge and a thrill.

Each tool felt like another piece of a massive puzzle. The more pieces I added, the more Kubernetes began to reveal itself as less of a monster and more of a meticulously designed machine.

Tailoring the DevOps Toolbox

Let’s not forget the unsung heroes: the tools that make the day-to-day manageable. As someone who spends hours in the terminal, customisation became my mantra. Zsh with Oh My Zsh gave my shell personality, Starship added flair, and fzf and tmux made navigating and multitasking smoother than ever. Each tweak felt like shaving seconds off a command, making every interaction just a bit more seamless.

And then there was my beloved VSCode. Plugins like GitLens brought version control to life, while VSCodeVim let me embrace modal editing. Small changes, big productivity gains—it’s amazing how a tailored environment can enhance your workflow.

Adventures with Docker and Harbor

No Kubernetes journey is complete without Docker. Building, tagging, and pushing images became second nature, but my true "Eureka!" moment came with Harbor, a container registry that elevated the process with automation and security. Setting up pull secrets to link Harbor and Kubernetes was a proper rite of passage, complete with a healthy dose of trial and error.

Synchronising Harbor with Kubernetes felt like teaching two strong-willed personalities to get along. Frustrating at times? Absolutely. Satisfying when it worked? Even more so. It taught me that automation isn’t just a convenience—it’s a necessity.

The Linux Chronicles

Kubernetes may be the main act, but Linux was the stage. From installing Ubuntu to troubleshooting permissions, Linux was the backbone of everything I did. It’s the unsung hero of DevOps—a system that quietly runs the show while we wrangle our YAMLs. Mastering the command line and understanding package management was like learning the language of the machines I was working with.

The Sandbox That Was MicroK8s

Before diving into live clusters, I experimented with MicroK8s, a lightweight Kubernetes distribution perfect for learning. It was a forgiving playground where I could deploy apps, mess up RBAC configurations, and troubleshoot network policies—all without fear of breaking a production environment. Mistakes weren’t just tolerated; they were welcomed. And with each error came a lesson.

The Art of Documentation: Writing for Humans

Although I haven’t started working directly with Welkin (Elastisys’ Kubernetes platform) yet, I’m gearing up for an exciting upcoming task: reviewing it from the perspective of a developer and end-user. The goal? To assess the experience of using Welkin, highlighting both the advantages and potential challenges it presents for someone with limited Kubernetes experience.

This task isn’t about evaluating the installation process—that requires more advanced Kubernetes administration skills than what’s expected of a newcomer. Instead, it’s about stepping into the shoes of a developer leveraging Welkin’s features. How intuitive is the platform? Are its tools accessible? Does it enable smooth development workflows? By approaching it with a beginner’s mindset, I hope to provide valuable feedback on how Welkin serves developers and how it might be improved for users at different experience levels.

For now, my internship has been focused on building the foundational skills and understanding necessary to tackle this challenge after Christmas. It’s an opportunity I’m eager to embrace, combining technical insight with the empathy needed to make complex tools approachable for all.

Observability: Bringing Order to Chaos

Observability was my light in the Kubernetes darkness. Tools like Grafana and Prometheus made it possible to understand what was happening beneath the surface. Setting up dashboards, visualising metrics, and configuring alerts didn’t just make the system manageable—it made it visible. Suddenly, Kubernetes wasn’t a black box; it was a living, breathing ecosystem I could monitor and improve.

What’s Next: Welkin and Beyond

While my school-affiliated internship has officially ended, my time with Elastisys continues for a few more months. After Christmas, I’ll dive into Welkin. This is the challenge I’ve been gearing up for, combining everything I’ve learned—from debugging YAML to working with container registries.

And long-term? The Certified Kubernetes Administrator (CKA) exam is on my radar. But for now, it’s about mastering the foundations, embracing the learning curve, and keeping that curiosity alive.

Final Thoughts: Laughing Through the YAML

Kubernetes is a beast, no doubt about it. It’s temperamental, complex, and prone to surprises just when you think you’ve got it figured out. But it’s also fascinating, rewarding, and endlessly empowering.

If there’s one thing this internship has taught me, it’s this: success in tech isn’t about knowing everything. It’s about curiosity, resilience, and—let’s be honest—the ability to laugh at yourself when a typo in your YAML brings your cluster to its knees.

Here’s to the next chapter of this Kubernetes adventure. Let’s see what Welkin—and beyond—has in store.