You Probably Don't Need Kubernetes (Yet)

Let’s rip the band-aid off immediately. I’ve sat in too many meetings in Oslo boardrooms where a startup with three microservices is trying to deploy a multi-region Kubernetes federation. It is absolute madness. You are burning engineering hours on managing a control plane when you should be shipping code.

As of April 2024, the container orchestration landscape has stabilized, but the hype cycle hasn't. Everyone wants the resume points of being a "K8s Administrator," but few understand the hardware tax that comes with it. If you are operating out of Norway, dealing with Datatilsynet (Data Protection Authority) requirements and GDPR, adding layers of abstraction often just adds layers of liability.

Here is the battle-hardened reality of running containers in 2024: latency kills, disk I/O is the bottleneck nobody talks about, and simplicity is the only way to sleep at night.

The Heavyweight: Kubernetes (K8s) v1.29

Kubernetes is the standard. It is also a beast. In version 1.29 (Mandala), we saw improvements in sidecar containers and immutable config maps. It's powerful. But here is the war story: I recently audited a setup for a client hosting e-commerce sites targeting the Nordic market. They were experiencing random API timeouts.

The culprit wasn't their Go code. It was etcd latency. Their previous provider (not CoolVDS) had them on "standard SSDs" with noisy neighbors. Kubernetes' brain, etcd, requires extremely low fsync latency. If the disk writes hang, the leader election fails, and the cluster panics.

If you commit to K8s, you must control the hardware. You need dedicated resources. Here is a snippet of a proper ResourceQuota configuration to prevent a single namespace from eating your node's CPU, something many forget until their production node crashes:

apiVersion: v1
kind: ResourceQuota
metadata:
  name: compute-resources
  namespace: production
spec:
  hard:
    requests.cpu: "4"
    requests.memory: 8Gi
    limits.cpu: "8"
    limits.memory: 16Gi
    pods: "20"

The Pragmatic Alternative: HashiCorp Nomad

While K8s tries to be an operating system for the cloud, Nomad just wants to schedule jobs. It is a single binary. It is fast. In 2024, Nomad 1.7 introduced better identity handling and workload identity, bridging the gap with K8s security features.

Why do I prefer this for mid-sized Norwegian deployments? Because I can explain the architecture to a junior dev in 20 minutes. It integrates seamlessly with Consul for service discovery without the networking voodoo of K8s CNI plugins.

A Nomad job file is readable by humans, not just parsers:

job "api-service" {
  datacenters = ["oslo-dc1"]
  type = "service"

  group "api" {
    count = 3
    network {
      port "http" {
        static = 8080
      }
    }
    task "server" {
      driver = "docker"
      config {
        image = "coolvds/api:v2.4"
        ports = ["http"]
      }
      resources {
        cpu    = 500
        memory = 256
      }
    }
  }
}

The Hardware Reality: Why Your VPS Matters

Regardless of whether you choose K8s, Nomad, or just plain Docker Compose (which is perfectly fine for 90% of use cases), the underlying OS matters. Virtualization overhead is the enemy of container density.

This is where the "CoolVDS" architectural decision pays off. We rely on KVM (Kernel-based Virtual Machine). Unlike container-based virtualization (LXC/OpenVZ) used by budget providers, KVM gives you a dedicated kernel. This is non-negotiable for running Docker. If you run Docker inside a containerized VPS (inception style), you run into specific kernel module issues and overlayfs limitations.

Pro Tip: Always benchmark your disk I/O before installing a cluster. Use fio to ensure your provider isn't throttling IOPS. K8s requires high write IOPS for the state store.

Run this on your current server. If the result scares you, move:

fio --name=random-write --ioengine=posixaio --rw=randwrite --bs=4k --size=1g --numjobs=1 --runtime=60 --time_based --end_fsync=1

On our NVMe instances at CoolVDS, we optimize specifically for this pattern. We know that `fsync` speed correlates directly to API response times when databases are involved.

Latency and Sovereignty: The Norwegian Context

Latency isn't just about speed; it's about conversion rates. If your user is in Bergen and your server is in a massive datacenter in Frankfurt, you are adding 20-30ms of round-trip time (RTT) unnecessarily. If you route through NIX (Norwegian Internet Exchange), that drops to single digits.

Furthermore, under GDPR and the lingering effects of Schrems II, keeping data processing within national borders is a massive compliance advantage. When you deploy a K8s cluster on a US-owned cloud, even if the region is "Europe," the legal framework is complex. Using a local VPS provider simplifies the "Transfer Impact Assessment" your legal team is nagging you about.

Comparison: The Cost of Complexity

Optimizing the Node

If you decide to go with a simple Docker setup on a robust VPS, don't ignore the sysctl settings. Linux defaults are often tuned for 2010 hardware, not 2024 NVMe speeds.

Add this to your /etc/sysctl.conf to handle high-traffic container networking without dropping packets:

# Increase connection tracking table size
net.netfilter.nf_conntrack_max = 131072

# Enable TCP BBR for better throughput over the public internet
net.core.default_qdisc = fq
net.ipv4.tcp_congestion_control = bbr

# Reduce swapping to prioritize application memory
vm.swappiness = 10
vm.vfs_cache_pressure = 50

Apply it with `sysctl -p`. The BBR congestion control algorithm alone can improve throughput for your users on mobile networks significantly.

The Verdict

Do not resume-drive your infrastructure. If you need auto-scaling and have a team of 5 DevOps engineers, go Kubernetes. If you want 80% of the features with 20% of the headache, look at Nomad.

But if you just need to run three apps reliably, get a high-performance CoolVDS instance, install Docker, and secure it with a local firewall. The raw performance of NVMe storage and the low latency of local peering will outperform a poorly managed K8s cluster every single time.

Ready to test your container performance? Deploy a CoolVDS NVMe instance in Oslo today and see what sub-millisecond I/O latency actually feels like.