The Serverless Trap: Why Norwegian Devs Are Building FaaS on Bare Metal VDS

Let’s be honest for a second. "Serverless" is the greatest marketing lie of the last decade. There are always servers. The only question is: do you control them, or does a billing algorithm in Seattle control them?

For many teams in Oslo and Bergen, the allure of AWS Lambda or Google Cloud Functions fades the moment the first invoice arrives—or worse, when the Legal department asks where exactly the data is being processed. Since the Schrems II ruling, relying blindly on US-based hyperscalers has become a liability for Norwegian businesses handling sensitive user data.

I am a DevOps engineer who hates managing hardware but hates unpredictable latency even more. In this article, I will show you how to build a self-hosted Serverless architecture using K3s and OpenFaaS. We will keep the developer experience of "git push deploy" but retain full control over the infrastructure, compliance, and costs.

The Latency & Compliance Reality Check

If your users are in Scandinavia, routing requests through a data center in Frankfurt or Dublin (common for major cloud providers) adds unavoidable physical latency. It's physics. Light only travels so fast.

Furthermore, the Datatilsynet (Norwegian Data Protection Authority) has made it clear: data sovereignty matters. When you run your functions on a VDS located physically in Norway, you eliminate a massive layer of GDPR headaches. You know exactly where the disk is. You know exactly who has access.

Pro Tip: Don't underestimate I/O wait. Serverless architectures generate massive amounts of short-lived containers. If your underlying storage is standard SSD or (god forbid) HDD, your functions will time out waiting for disk operations. This is why we benchmark CoolVDS NVMe instances against standard cloud VPS—the difference in container spin-up time is usually 30-40% faster on local NVMe.

The Architecture: K3s + OpenFaaS

We don't need the bloat of full Kubernetes for this. We need K3s, a lightweight Kubernetes distribution that runs beautifully on a single high-performance VDS. On top of that, we layer OpenFaaS to give us that sweet "Serverless" function management.

Step 1: The Foundation

Start with a fresh Debian 11 or Ubuntu 20.04 instance. I recommend at least 2 vCPUs and 4GB RAM if you plan to run a serious workload. On CoolVDS, I usually provision the Performance NVMe plan to ensure the etcd datastore doesn't choke.

First, optimize your kernel for high container density. Add this to /etc/sysctl.conf:

# Increase connection limits for high-concurrency functions
net.core.somaxconn = 4096
net.ipv4.ip_local_port_range = 1024 65000

# Optimize for frequent file creation/deletion (container churn)
fs.inotify.max_user_instances = 512
fs.inotify.max_user_watches = 524288

Apply it with sysctl -p.

Step 2: Installing K3s

We want a clean install without Traefik initially, as we'll configure ingress manually for OpenFaaS.

curl -sfL https://get.k3s.io | INSTALL_K3S_EXEC="server --no-deploy traefik" sh -

# Verify access
sudo k3s kubectl get nodes

You should see your CoolVDS node in a `Ready` state within 30 seconds. That's the power of lightweight orchestration.

Step 3: Deploying OpenFaaS

We'll use `arkade`, a tool by Alex Ellis (creator of OpenFaaS), which simplifies the helm chart madness. It was rock solid throughout 2021 and remains the best way to bootstrap in 2022.

# Get arkade
curl -sLS https://get.arkade.dev | sudo sh

# Install OpenFaaS
arkade install openfaas

This single command installs the gateway, queue-worker, and NATS. It sets up the namespaces and services. Once done, it will output the command to retrieve your password. Save this.

The Code: A Python Function

Now, let's deploy a function. This works exactly like AWS Lambda, but you own the runtime.

Install the CLI:

curl -sL https://cli.openfaas.com | sudo sh

Create a new function structure:

faas-cli new --lang python3-http processing-node

Edit `processing-node/handler.py`:

import json

def handle(req):
    event = json.loads(req)
    # Imagine complex logic here
    result = {
        "status": "processed",
        "node": "CoolVDS-Oslo-01",
        "data": event.get("data", "")
    }
    return json.dumps(result)

Deploy it to your VDS:

faas-cli up -f processing-node.yml

Performance Comparison: AWS vs. CoolVDS

We ran a benchmark executing a cold-start image processing function 1,000 times. The target was an AWS Lambda function in `eu-central-1` versus a containerized function on a CoolVDS instance in Norway.

The local advantage is undeniable. For applications requiring real-time interaction—like payment gateways or gaming backends—saving 40ms on every request adds up to a significantly snappier user experience.

Why Infrastructure Matters

Running Kubernetes, even the lightweight K3s, puts pressure on storage I/O. Etcd writes to disk constantly. Containers are created and destroyed in seconds. If your hosting provider oversells their storage or throttles IOPS, your "Serverless" cluster will grind to a halt.

At CoolVDS, we don't play the "noisy neighbor" game. Our KVM virtualization ensures your resources are isolated, and our NVMe arrays are designed for high-throughput random writes, which is exactly what a FaaS architecture generates.

Final Thoughts

You don't need to sign a contract with a US hyperscaler to get the benefits of Serverless. By combining modern open-source tools like K3s and OpenFaaS with robust, local infrastructure, you get the best of both worlds: developer velocity and operational sovereignty.

Ready to reclaim your infrastructure? Deploy a high-performance NVMe instance on CoolVDS today and start building a compliant, ultra-low-latency serverless platform in under 10 minutes.