Kubernetes vs. Swarm vs. Nomad: The 2022 Orchestration Survival Guide for Nordic Ops

Let's be honest: most of you don't need Kubernetes. I know, it's heresy to say that in 2022. Everyone wants to put "K8s Administrator" on their LinkedIn profile, but I've seen too many startups burn months of runway trying to debug CrashLoopBackOff errors when a simple docker-compose up would have sufficed.

However, once you hit a certain scale, manual management is a death sentence. I recall a project back in 2019 involving a high-traffic e-commerce site targeting the Scandinavian market. We tried to manage 20 nodes with Ansible scripts and prayers. When Black Friday hit, the latency spiked, nodes drifted out of sync, and I didn't sleep for 48 hours. That was the last time I underestimated orchestration.

Today, we are looking at the three contenders fighting for your CPU cycles: Kubernetes, Docker Swarm, and HashiCorp Nomad. We will judge them not on hype, but on operational reality, specifically within the context of European hosting requirements like Schrems II and latency constraints across the Nordics.

The 800lb Gorilla: Kubernetes (K8s)

Kubernetes is the standard. It has won the war. But winning the war doesn't mean it's right for your skirmish. With the recent removal of Dockershim in v1.24, the ecosystem is shifting towards containerd and CRI-O, reducing some overhead, but the control plane remains heavy.

The Hidden Cost: etcd Latency

Here is what the tutorials don't tell you: K8s is addicted to disk I/O. The state store, etcd, is incredibly sensitive to write latency. If your fsync times drift, the cluster loses quorum and falls apart. This is a common disaster on budget VPS providers that oversell storage I/O.

When we provision K8s clusters on CoolVDS, we rely strictly on local NVMe storage. If you are running K8s on network-attached storage or standard SSDs with noisy neighbors, you are asking for trouble. Here is a quick fio check we run before even attempting a kubeadm init:

If the 99th percentile latency here is above 10ms, do not install Kubernetes. On our CoolVDS NVMe instances in Oslo, we usually see this well under 2ms.

The Config Beast

K8s requires verbose YAML. To expose a simple Nginx service, you need a Deployment, a Service, and likely an Ingress. It looks like this:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nordic-web
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.21-alpine
        resources:
          limits:
            memory: "128Mi"
            cpu: "500m"
---            
apiVersion: v1
kind: Service
metadata:
  name: nordic-svc
spec:
  selector:
    app: nginx
  ports:
    - port: 80
      targetPort: 80

The Zombie: Docker Swarm

Is Swarm dead? Mirantis acquired Docker Enterprise back in 2019, and while the buzz is gone, Swarm is still shipping with Docker CE. For teams of 2-5 developers, Swarm is arguably superior because the cognitive load is near zero.

Swarm uses the same docker-compose.yml syntax you use in development. There is no translation layer. Networking is built-in via overlay networks. However, it lacks the extensibility of K8s. You don't have CRDs (Custom Resource Definitions) or the massive Helm chart ecosystem.

To deploy the same stack in Swarm:

version: "3.8"
services:
  web:
    image: nginx:1.21-alpine
    deploy:
      replicas: 3
      resources:
        limits:
          cpus: "0.50"
          memory: 128M
    ports:
      - "80:80"

Run docker stack deploy -c docker-compose.yml nordic_stack and you are done. It works brilliantly until you need complex stateful sets or advanced autoscaling logic.

The Sniper: HashiCorp Nomad

Nomad is the tool for the "Pragmatic CTO." It is a single binary. It handles non-containerized workloads (Java JARs, static binaries) just as well as Docker containers. In 2022, Nomad fits a specific niche: high efficiency and mixed workloads.

Nomad doesn't eat your RAM just to run its control plane. We have seen Nomad clusters scale to 10,000 nodes without the sweating that K8s exhibits at 5,000. It uses the HCL (HashiCorp Configuration Language), which is cleaner than JSON/YAML.

job "nordic-web" {
  datacenters = ["oslo-dc1"]
  group "web" {
    count = 3
    task "nginx" {
      driver = "docker"
      config {
        image = "nginx:1.21-alpine"
      }
      resources {
        cpu    = 500
        memory = 128
      }
    }
  }
}

Infrastructure & Compliance: The "Schrems II" Reality

Regardless of which orchestrator you choose, your data must live somewhere. Since the Schrems II ruling, relying on US-owned hyperscalers involves complex legal gymnastics for European data. The Datatilsynet (Norwegian Data Protection Authority) has been increasingly strict.

This is where the infrastructure layer becomes a compliance feature. Hosting your K8s or Nomad cluster on CoolVDS in Norway provides data sovereignty. Your bits stay in Oslo. They don't route through a US-controlled control plane.

Network Tuning for Orchestrators

Orchestrators rely heavily on iptables or IPVS. A common bottleneck on standard Linux distributions is the connection tracking table limit. If you are pushing high throughput, you need to tune your sysctl.conf:

# /etc/sysctl.conf
net.netfilter.nf_conntrack_max = 131072
net.bridge.bridge-nf-call-iptables = 1
net.ipv4.ip_forward = 1
vm.swappiness = 1  # Keep RAM for containers, not swap

Pro Tip: If you use CoolVDS, we optimize the underlying KVM hypervisor network drivers (virtio-net) to handle the packet fragmentation that overlay networks (like Calico or Flannel) generate. This reduces the "soft lockup" CPU spikes common in virtualized K8s clusters.

Comparison: The 2022 Snapshot

Final Verdict

If you need to hire 10 engineers next month, choose Kubernetes. It is the industry dialect. Just ensure you have the IOPS to support it.

If you are a team of three building a SaaS MVP, choose Swarm. It will get you to market faster.

If you need raw performance and low overhead, or need to orchestrate legacy binaries alongside Docker, Nomad is your weapon of choice.

But remember: an orchestrator is only as stable as the metal it runs on. Latency jitter kills distributed systems. Don't let a slow network in Frankfurt kill your user experience in Trondheim. Build on local, high-performance infrastructure.

Ready to architect for stability? Deploy a high-frequency NVMe instance in Oslo on CoolVDS today and see the difference raw power makes for your cluster.