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

Let’s be honest. Most of you deploying Kubernetes today don't actually need it. You are buying a Ferrari to drive to the Kiwi grocery store.

It is June 2022. The hype cycle for containers has settled into a harsh reality of complexity management. If you are running a DevOps team in Oslo or managing infrastructure across Europe, the question isn't "can we containerize it?" It's "how do we orchestrate this without burning out our on-call engineers?"

I have spent the last six months migrating a legacy monolithic platform for a Norwegian fintech client. We evaluated the "Big Three" orchestrators. The goal? High availability, strict Schrems II compliance (keeping data out of US clouds), and sub-millisecond latency. Here is the unvarnished truth about the state of container orchestration right now.

The Latency Trap: Why Your Hardware Matters More Than Your Orchestrator

Before we argue about YAML indentation, we need to talk about physics. You can have the most optimized Kubernetes cluster, but if your underlying storage layer is slow, etcd will choke. And when etcd chokes, your cluster dies.

In a recent incident, we saw a cluster implode because the hosting provider's "SSD" storage had highly variable fsync latency. Kubernetes is ruthless about this. If the leader cannot write to the WAL (Write Ahead Log) fast enough, leader election triggers, and the control plane flaps.

This is where the choice of VPS provider becomes an architectural decision, not just a billing one.

We switched that workload to CoolVDS NVMe instances. The difference wasn't subtle. Stable IOPS are the heartbeat of orchestration. If you are running your own control plane, run this test before you install a single K8s node:

fio --name=etcd-test --rw=write --ioengine=sync --fdatasync=1 \
--size=100m --bs=2300 --numjobs=1

If your 99th percentile fsync latency is above 10ms, do not deploy Kubernetes. You are building on sand.

The Contenders: 2022 Edition

1. Docker Swarm: The "Dead" Tech That Won't Die

Every year pundits say Swarm is dead. Yet, here we are in 2022, and it remains the fastest way to go from zero to clustered.

The Good: It is built into the Docker engine. No extra binaries. The learning curve is non-existent if you know `docker-compose`.

The Bad: It lacks the rich ecosystem of CRDs (Custom Resource Definitions) that K8s has. Autoscaling logic is primitive.

The Use Case: Small to medium teams hosting web apps where you control the whole stack. For a client needing a simple HA setup for a Magento store, Swarm on three CoolVDS nodes behind a load balancer is bulletproof and cheap.

# Initializing a Swarm is still the best UX in the industry
docker swarm init --advertise-addr 10.10.20.5

# Deploying a stack
docker stack deploy -c docker-compose.yml production_app

2. Kubernetes (v1.24): The Industrial Standard

With the release of version 1.24 in May, the dockershim is officially removed. If you are still relying on mounting /var/run/docker.sock, your pipelines are about to break. This is the maturity phase of K8s. It is powerful, extensible, and complex.

The War Story: We manage a cluster handling financial transactions. We needed strict network policies to isolate namespaces. K8s allows us to use Calico or Cilium for eBPF-based filtering. That is security you can audit.

However, running K8s requires resources. The control plane components (API server, scheduler, controller-manager) eat RAM. On a cheap, oversold VPS, the API server becomes sluggish. We deploy our masters on CoolVDS High-CPU instances to ensure the scheduler acts instantly.

# Checking etcd health is a daily ritual
kubectl get --raw='/readyz?verbose'

# A simple NetworkPolicy to deny all traffic by default (Zero Trust)
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: default-deny-all
  namespace: payment-gateway
spec:
  podSelector: {}
  policyTypes:
  - Ingress
  - Egress

3. HashiCorp Nomad: The Unix Philosophy Choice

Nomad is the dark horse. It doesn't just run containers; it runs Java jars, binaries, and scripts. It integrates tightly with Consul and Vault.

Why use it? Simplicity. A single binary. No massive collection of microservices just to run the orchestrator itself. For teams already using Terraform, Nomad feels like home.

Pro Tip: If you need to mix legacy binaries (that can't be containerized easily) with Docker containers, Nomad is your only real option. Kubernetes makes this painful; Nomad makes it native.

# A simple Nomad job spec (HCL)
job "docs" {
  datacenters = ["oslo-dc1"]

  group "web" {
    count = 3
    task "server" {
      driver = "docker"
      config {
        image = "nginx:1.21"
        ports = ["http"]
      }
      resources {
        cpu    = 500
        memory = 256
      }
    }
  }
}

The Compliance Angle: Schrems II and Data Sovereignty

This is critical for Norwegian businesses. The Datatilsynet is watching. Relying on US-based managed Kubernetes services (EKS, GKE, AKS) creates a complex legal surface area regarding data transfers.

By deploying your own orchestrator (be it Swarm or K8s) on CoolVDS infrastructure located in Europe, you gain definitive control. You know exactly where the drives spin. You know the bits aren't being replicated to a bucket in Virginia without your consent.

Comparison: What fits your team?

Optimizing the Node: Kernel Tuning for Containers

Regardless of your choice, the default Linux kernel settings are rarely optimized for high-density container loads. We apply these sysctl tweaks on all our CoolVDS nodes before bootstrapping a cluster:

# /etc/sysctl.d/99-k8s.conf

# Increase the limit on inotify watchers (essential for log aggregators)
fs.inotify.max_user_watches = 524288

# Allow more connections to be tracked
net.netfilter.nf_conntrack_max = 131072

# Optimize swap usage (don't swap unless absolutely necessary)
vm.swappiness = 1

# Enable IP forwarding (Required for CNI plugins)
net.ipv4.ip_forward = 1

Apply these with sysctl -p. If you skip the inotify setting, your `kubectl logs -f` commands will randomly fail when the cluster grows.

Conclusion: Choose Complexity Wisely

In 2022, Kubernetes won the marketing war, but it might lose the TCO battle for your specific use case. If you have a team of two, run Swarm. If you have a legacy hybrid stack, run Nomad. If you are building the next Vipps or massive SaaS platform, run Kubernetes.

But whatever you run, do not starve it of I/O. Orchestrators are just management layers; they cannot fix slow hardware.

Ready to build a cluster that doesn't flake? Spin up a high-performance, NVMe-backed instance in our Oslo-adjacent datacenter. With CoolVDS, you get the raw power your orchestrator demands, with the data privacy your legal team requires.

Deploy your control plane on CoolVDS today.