Beyond Kubernetes: Choosing the Right Infrastructure Abstraction
The Importance of Simplicity
Simplicity is, in my view, the foundation of sustainable software development. Minimal dependencies and clear boundaries ensure maintainability and stability. However, as soon as a developed service goes into production, the modern world looks completely different: neither simplicity nor minimal dependencies are present. Instead, countless tools are employed to operate these services.
Lessons from the Past
In the early 2000s, I worked at WEB.DE. Compared to today’s tooling, one wonders how such immense online operations were even possible. The answer is simple: people understood the fundamentals. Those who know the building blocks of a system face no limits. And it wasn’t hundreds of people responsible for operations—just a small, double-digit number.
The Modern Cloud World
Nowadays, online operations almost automatically mean the cloud. It’s convenient and adapts to all circumstances—but it comes with a long chain of tools for CI/CD, building & packaging, Infrastructure as Code (IaC), orchestration, deployment, and monitoring. The problem isn’t the steps themselves, but the use of generic tools that set a de facto standard and go far beyond solving a single problem by offering entire platforms.
The Linux Philosophy
The Linux approach—where a tool solves one specific problem and does it really well—is brilliant. If multiple tools exist for one purpose, I can choose the most suitable one or even contribute my own building block if I don’t want to use an off-the-shelf solution. However, this modular, flexible approach requires a deep understanding of the underlying processes. I often observe that the focus has shifted from understanding the problems to just accepting the tools as given.
AWS and Kubernetes
AWS was built to create a flexible platform for Amazon—a solution that was then successfully marketed. But what was good for Amazon doesn’t necessarily fit everyone. Similarly, Kubernetes emerged when smart minds at Google generalized their internal solutions, inspired by the success of AWS. Kubernetes is a de facto standard today, not least because of its prestigious origin.
The Role of Kubernetes
Kubernetes provides a portable environment supported by almost every relevant provider. This makes it attractive, as it allows for vendor independence. However, Kubernetes itself is already a dependency. It should be a conscious decision to evaluate why you want to use Kubernetes. For many use cases, a few compute units costing a fraction of the price might be sufficient.
Alternatives to Kubernetes
Obviously, Kubernetes is used for service orchestration. For smaller setups, Docker Swarm is an alternative. For more flexibility, as it is not limited to containers, HashiCorp Nomad is worth a look. Depending on the use case, tools like Docker Compose, Ansible, or Kamal can also be sensible choices.
Autoscaling and Self-Healing
An exciting topic in Kubernetes is autoscaling and self-healing. These features are non-trivial to build yourself and require a deeper understanding. However, this is often a theoretical problem. Many applications have predictable resource requirements, and even with a buffer for failures, a simpler setup can be more cost-effective.
Service Discovery and Load Balancing
Service discovery and load balancing are other critical points. Good solutions can be implemented even without Kubernetes, for example with Consul and HAProxy. A Traefik cluster can not only automatically include Docker containers in the distribution but also handle certificate management.
Update Strategies and Configuration Management
Update strategies can be implemented with ArgoCD. Traefik or NGINX support blue-green deployments. For secrets and config management, HashiCorp Vault is a useful building block.
Abstraction and Platforms
The more of the mentioned points you need to cover, the more sense it makes to use Kubernetes as a comprehensive solution. If you want to focus more on the application than on containers, it’s worth looking at CloudFoundry or platforms like Heroku, Netlify, or Vercel. Open-source alternatives include Coolify or Tau from Taubyte.
Understanding the Fundamentals
The crucial point is to engage with the underlying building blocks. Could you build a setup like Kubernetes yourself? Do you understand the components and can you evaluate what you truly need? For VM-based setups, cloud-init provides a solution for basic provisioning. A deep understanding of the fundamentals allows you to consciously weigh complex platforms against leaner alternatives. Simplicity remains the key to creating efficient, maintainable, and cost-effective systems that meet actual requirements.