Tom Meurs

Talos Linux Vendor Lock-In: Five Questions, Run on My Own Nodes

Tue, 06 Oct 2026 09:00:00 +0200

TL;DR I ran the five questions from my licence post on the OS under my own cluster. The licence holds. The Talos Linux vendor lock-in sits in two defaults that point at Sidero’s servers, the BSL code Sidero keeps adding around the MPL core, and a company Yardi has owned since 14 September.

Supply Chain Security in GitLab CI: SBOM, cosign, and the Policy That Blocks

Tue, 29 Sep 2026 09:00:00 +0200

TL;DR A pipeline that scans images and writes an SBOM, with nothing checking either at admission, had been green for a year and had stopped nothing. Four steps below: an SBOM Trivy can read back, a cosign signature on the digest with the key in Vault, the SBOM attached as an attestation, and a Kyverno policy that refuses the rest. Then a table of which SLSA Build L3 requirements a self-hosted GitLab runner meets, and the two it doesn’t.

Your Dependency's Business Model Is Part of Your Threat Model

Wed, 23 Sep 2026 19:00:00 +0200

TL;DR A vendor freezing its free edition belongs in your risk register next to the expiring certificate. Thirty-six dated cases below, three kinds of event, and five questions to score your own stack. My own register had the Vault row missing for three years.

On 11 September, Portainer’s CEO published “Portainer 3.0 is coming, and here’s what it means for you”. I read it the Monday after and shrugged.

Here’s what it says. 3.0 is a Kubernetes-first codebase for enterprise customers, and “we are not cutting a separate CE build of it”. Community Edition stays on 2.x. 2.45 LTS “is the last release in the 2.x line”. A few days later they added a clarification: 2.45 keeps getting security fixes, bug fixes and back-ports of any 3.x feature that has a Docker API equivalent, “for as long as that LTS is supported”. The lifecycle page puts that at May 2027. Want 3.x for free? There’s a Business Edition key called 3 Nodes Free, one per organisation.

NIS2 for Platform Teams: Which Control Satisfies Which Article

Sun, 20 Sep 2026 21:00:00 +0200

TL;DR The Cyberbeveiligingswet has applied since 15 August 2026. Below, the ten measures of article 21 mapped onto controls that actually run, a Kyverno policy that proves one of them, the reporting deadlines as three Prometheus alerting rules, and the four duties no YAML covers. The first run of that policy found seven pods in my own cluster I’d have sworn were mirrored.

Linux Is for Everyone: Why This Blog Now Welcomes Beginners Too

Thu, 11 Jun 2026 20:28:00 +0100

My neighbour is 70 years old. He’s used Windows his whole life. Last month he asked me: “Tom, I keep hearing about Linux. Is that something for me too?”

He’s not the first. Over the past year I’ve had the same question from friends, family and colleagues, each in their own shape. “I want to get off Windows, but where do I start?” “Is Linux hard?” “Can I still use my normal programs?” To me these are easy questions. I’ve been running Linux since SuSE 6.0, back when you picked your hardware by whether a Linux driver existed for it. If you’ve never seen a terminal, they’re not easy at all.

Data Poisoning: Reclaiming Your Privacy Through Offence

Sun, 07 Jun 2026 21:43:00 +0100

Here’s how privacy works today. You read the policy. You dismiss the cookie banner. You hunt through three settings menus for the opt-out toggle that someone buried on purpose. All of that to exercise a right that should’ve been the default. And while you’re still on the first paragraph of the terms of service, every click, scroll, hover and the exact timing of your keystrokes has already been harvested, packaged and sold. Somewhere along the way I stopped finding that strange, and that bothers me more than the harvesting does.

KVM/QEMU Scripts and Aliases: Making Virtualization Actually Usable

Wed, 03 Jun 2026 21:17:00 +0100

I run VMs all day. A Kubernetes deployment I want to test, a distro I read about, Windows for that one stubborn application, an experiment I’d rather not run on my actual machine. KVM/QEMU is the right tool for all of it. It lives in the Linux kernel and runs close to native speed. Nothing in it phones home, and no vendor gets a say in what I do with my own hardware.

Infrastructure as Code for People Who Need to Understand

Sat, 30 May 2026 19:45:00 +0100

Someone opens a cloud console, clicks through a wizard, accepts a few defaults, and a resource appears. The dashboard goes green and everyone moves on. That’s still how a lot of infrastructure gets built in 2026, and I’ve built some of it that way myself.

I can’t work like that for long. When I click a button and infrastructure appears, it feels borrowed. I want the configuration written down somewhere I can read it back, and I want to know why something exists, not only that it exists. The console gives me a green tick. It doesn’t give me any of that.

Backup Strategy for Your Homelab: The 3-2-1 Rule in Practice

Mon, 18 May 2026 19:30:00 +0100

TL;DR Three copies, two kinds of media, one of them offsite. Restic for files, Velero for the cluster, a Backblaze bucket for the offsite copy, and a restore test on a schedule. Mine costs about €5 a month, and the restore test is the part I still have to make myself do.

Picture the disk in your homelab dying tonight. Not corrupting, not throwing SMART warnings for a week first, just gone. The git server with every repo you care about, the password vault, fifteen years of family photos, the home automation that runs the house. All of it on a drive that’s decided it’s done.

Terminal Multiplexing: tmux vs Zellij vs Screen

Thu, 14 May 2026 19:00:00 +0100

The first time it bit me I was halfway through a database migration over SSH. The train went into a tunnel, the WiFi dropped, and the process on the other end died with the connection. I sat looking at a dead prompt, wondering how much of the migration had committed.

A multiplexer would have saved me that hour. The process keeps running on the server whether I’m attached or not, so a dropped connection costs me a reconnect and nothing else. I reattach and the work is where I left it. That one property is why a multiplexer goes on every machine I touch, before the editor and before the dotfiles.

Tailscale for Homelab: Secure Remote Access Without Port Forwarding

Sun, 10 May 2026 18:45:00 +0100

TL;DR Tailscale puts every device I own on one WireGuard mesh, so I reach the cluster in the closet from a coffee shop without a single port forwarded on the router. Subnet router, exit node, the Kubernetes operator, ACLs, and Headscale for the part I’d rather host myself, in that order.

My homelab cluster runs in a closet at home. I don’t. I work from coffee shops, from a client’s office, and now and then from a hotel with WiFi that seems to resent me. I still want my own machines while I’m out there.

Building an Internal Developer Platform: Where to Start

Wed, 06 May 2026 19:30:00 +0100

TL;DR An Internal Developer Platform is a thin layer between what a developer wants and what the cluster demands. Mine is a Helm base chart, ArgoCD and a handful of Kyverno policies, about 500 lines of my own code. Start with those three, and add observability and a portal only when the tickets tell you to.

Should you build an Internal Developer Platform? Usually, yes. It’s the how that wrecks teams.

Grafana Dashboards That Actually Get Used

Sat, 02 May 2026 20:15:00 +0100

TL;DR Each dashboard answers one question, and within five seconds I know whether I need to care. Four kinds of dashboard cover everything, variables and links tie them together, and the JSON lives in Git. My homelab runs five, and anything that goes a month unopened gets deleted.

You have Grafana. You have Prometheus metrics. You have logs in Loki and traces in Tempo. The data’s all there.

You also have 47 dashboards nobody opens.

Chaos Engineering: Breaking Your Cluster to Make It Stronger

Tue, 28 Apr 2026 19:45:00 +0100

TL;DR Chaos engineering is breaking your own cluster on purpose, with the hypothesis written down first and a rollback ready. I run it on the homelab with Litmus: a weekly pod-delete, a monthly node drain, a game day every quarter. So far it has found four things the dashboard would never have shown me.

My dashboard is a wall of green. Pods running, replicas matched, CPU comfortable, no alerts firing. I look at it and get that small hit of “everything’s fine.” And mostly it is. The cluster’s been up for weeks and nothing has fallen over.

K3s Cluster Setup on Refurbished Mini-PCs

Fri, 24 Apr 2026 21:12:00 +0100

TL;DR Three refurbished mini-PCs, K3s with embedded etcd, kube-vip for one API address that survives a dead node, then MetalLB, Traefik and Longhorn on top. About €450 in hardware and an afternoon. Below are the commands, in the order I ran them.

Three mini-PCs sit on a shelf in my house. Between them they run my GitLab, my monitoring stack, home automation, file sync, a password manager, and a pile of other things I’d rather not hand to someone else’s computer. The whole setup cost less than one month of the managed Kubernetes bill for the same thing, and I know what every layer does because I put it there.

Longhorn vs Rook-Ceph: Kubernetes Storage Compared

Mon, 20 Apr 2026 19:38:00 +0100

TL;DR Longhorn and Rook-Ceph both give you replicated block storage that survives a node dying. Longhorn is one Helm install and a UI that shows you what a volume is doing. Rook-Ceph is Ceph with a Kubernetes operator around it, so you get block, object and filesystem storage, and the operations that come with them. I run Longhorn on three nodes. Below is why, and when I’d switch.

Run your first stateful workload on a self-hosted cluster and you find out fast that nobody hands out PersistentVolumes for free. There’s no cloud provider storage class to lean on. You’ve got your nodes, their disks, and a Postgres pod that won’t schedule. An hour of reading later you’re left with two names that keep coming up. Longhorn and Rook-Ceph .

Quantum-safe GPG identity with multiple aliases

Sat, 18 Apr 2026 10:47:00 +0200

TL;DR One GPG masterkey that only certifies, kept offline. Three aliases bound to it, so anyone can check they’re the same person. Ed25519 subkeys for signing and SSH, an ML-KEM plus X448 subkey for encryption so recorded ciphertext stays closed after a quantum computer shows up, and three backups that each assume the other two are gone. Needs GnuPG 2.5.

A cryptographic signature still means exactly what it says. If the key is yours and the signature verifies, the content came from you. No vendor handed you that identity, no CA can pull it, no platform can suspend it. It exists because you generated the key, and it’s yours for as long as you hold the private half. Most of what gets called “online identity” is borrowed. A handle someone can ban, an email address the domain owner can take back the day they feel like it. A GPG signature sits outside all of that.

Alerting That Works: From Alert Fatigue to Actionable Notifications

Thu, 16 Apr 2026 20:15:00 +0100

TL;DR Most default alert rules page on a number with no user behind it, and after a week of that you stop reading pages. I alert on error rate, P99 latency, a disk that fills within 24 hours and a certificate under seven days, about ten rules in total, each with a runbook. Alertmanager sends critical to the pager, warning to Slack during office hours, info nowhere. Everything that doesn’t need a human gets deleted.

cert-manager: Automatic TLS Certificates in Kubernetes

Sun, 12 Apr 2026 21:38:00 +0100

TL;DR cert-manager watches Certificate resources, fetches the certificate from Let’s Encrypt, your own CA or Vault, stores it in a Secret and renews it 30 days before it expires. I run one DNS-01 ClusterIssuer through Cloudflare and one wildcard certificate, copy that Secret into the namespaces that need it, and let two Prometheus alerts tell me when a renewal is stuck. Nothing left to remember.

For years my certificates renewed the way most people’s do. A calendar reminder, a manual certbot run, and the hope that I’d get to it before the thing expired. It worked, right up to the morning a service started throwing cert errors at me and I had no idea why. The renewal cron had been failing for weeks. Quietly.

Cilium: eBPF Networking for Kubernetes

Wed, 08 Apr 2026 20:23:00 +0100

TL;DR Cilium is the CNI I run in every cluster. It replaces kube-proxy and its iptables chains with eBPF programs in the kernel, enforces network policies on identity and on HTTP paths, and Hubble shows me every flow and every drop. WireGuard between the pods, BGP to the switch, no sidecars. My production values are at the bottom.

The first time a service stopped resolving in one of my clusters, I spent an evening reading iptables chains. Hundreds of rules, generated by kube-proxy, evaluated top to bottom. I never found the problem. I restarted the node and it went away.

Distributed Tracing with Tempo and OpenTelemetry

Sat, 04 Apr 2026 19:47:00 +0100

TL;DR Tempo is where my traces go. The OpenTelemetry Collector receives spans from every service, tail sampling keeps every error and every slow request, and Tempo writes the rest to MinIO with three days of retention. From a span in Grafana I click through to the Loki lines with the same trace ID. My production values are at the bottom.

Your metrics say something is slow. Your logs say errors happened. Fine. Which request failed, where did the latency come from, and which service in the chain ate the timeout? Neither of them can tell you.

Loki for Kubernetes Logging: The Prometheus-Like Approach

Tue, 31 Mar 2026 21:15:00 +0100

TL;DR Loki indexes labels and stores the log text as compressed chunks, so a month of logs fits on commodity hardware. The trade is full-text search. Below is the single-binary install I’d hand anyone first, the same chart on MinIO with three replicas, and the knobs I didn’t touch until the volume was real.

You’ve got Prometheus for metrics, so you can already see what’s happening across your clusters. Metrics tell you request latency spiked at 14:32. They don’t tell you the payment service threw a null pointer because someone shipped a config change with a typo. For that you need the log line.

Thanos Remote Write: Push-Based Metrics for Edge and Multi-Cluster

Fri, 27 Mar 2026 20:38:00 +0100

TL;DR Thanos Receive turns the metrics flow around. Each edge Prometheus pushes samples over remote_write to one central endpoint, buffers in its WAL when the link drops, and never sees an object storage credential. Below is the Receive StatefulSet, the hashring, the edge config, two ways to lock the endpoint down, and the hybrid I run with sidecars on the core clusters.

In my previous post on Prometheus and Thanos, I set up the sidecar architecture. Thanos Sidecar runs next to Prometheus, uploads TSDB blocks to object storage, and exposes the data to the Querier over gRPC. For clusters in the same datacenter with a fat, stable link to the central infrastructure, I’ve got no complaints. Everything pulls, and everything can reach everything else.

Declarative Infrastructure as Compliance Documentation: Talos, NixOS, and Audit-Ready Systems

Mon, 23 Mar 2026 19:28:00 +0100

TL;DR Talos and NixOS boot from a file that says what the machine is. That file is what an ISO 27001, SOC 2 or NIS2 auditor asks for, so the evidence collection shrinks to a git log, a diff with no output and an inventory dump. Below is the mapping from config to control, the scripts, and the part that stays hard work.

An ISO 27001 audit starts weeks before the auditor shows up, with someone collecting screenshots. Configuration panels, firewall rules, a dashboard that shows which patches went out. Then the Word documents that describe what the systems are supposed to do. Then the change tickets, dug out of the ticketing system, each one pointing at a “server maintenance” nobody can reconstruct six months later. Everyone treats this as the price of being in business. I did too, for years.

NixOS as a Hypervisor: KVM and QEMU Can Do Everything

Thu, 19 Mar 2026 21:52:00 +0100

TL;DR KVM and QEMU are the engine inside Proxmox and most of the cloud you rent. On NixOS, with libvirt on top, that engine is one block of config, and live migration, memory ballooning, GPU passthrough, SR-IOV and CPU pinning are each a command or an XML snippet away. What Proxmox adds is the dashboard and the delegation, and I’m honest below about how much that’s worth.

Ask around how to run a “real” hypervisor at home and you get the same shortlist. VMware, Hyper-V, or at minimum Proxmox. Something with a web UI, a clustering tab and a marketing page full of enterprise features. The shortlist is so well worn that running VMs without one of those products feels like cutting corners. I don’t blame anyone for that. The marketing is good.

NixOS vs Talos for Kubernetes Nodes: Two Flavors of Immutable Infrastructure

Sun, 15 Mar 2026 20:37:00 +0100

TL;DR Talos and NixOS are both declarative and both can be immutable, and that’s about where the resemblance stops. Talos runs Kubernetes and nothing else, with no shell to drift in. NixOS is a full Linux where the whole machine is one Nix config. I run Talos on my cluster nodes and NixOS on the machines around them, and this post is how I got to that split.

I’ve written about Talos Linux as the immutable Kubernetes OS, and I’ve compared Arch vs NixOS for workstations. After both, the same question kept arriving in my inbox. Why not NixOS on the Kubernetes nodes too?

Talos Linux: The Immutable Kubernetes OS That Changed How I Think About Nodes

Wed, 11 Mar 2026 21:15:00 +0100

TL;DR Talos Linux is a Linux that runs Kubernetes and nothing else. No SSH, no shell, no package manager. Every change goes through an API and a YAML file in Git. I’ve run my nodes on it for three years, and this post is how I stopped missing the shell.

The first time I tried to SSH into a Talos node, I got nothing. No shell, no connection, not even a login prompt. I sat there for a minute wondering how I was supposed to debug a machine I couldn’t get into.

The Lost Art of Software Optimization: What Demoscene Taught Us About Sustainability

Sat, 07 Mar 2026 20:42:00 +0100

Most of us ship software the same way now. Pick a framework, pull in a few hundred dependencies, and the service idles at a gigabyte of RAM before it does its first useful piece of work. Nobody profiles it. If it’s slow, you scale up. Compute is cheap, your time isn’t, and the bill goes to someone else. I don’t say that as a complaint. I’ve done it, and I’ll do it again on the next deadline.

Arch vs NixOS as a Workstation: Professional and Personal Use

Tue, 03 Mar 2026 21:28:00 +0100

TL;DR I’ve run Arch and NixOS as my daily machine, and today it’s Arch on both desktops and NixOS on the servers. Arch’s reputation for breaking is mostly a missing snapshot. With btrfs, Snapper, dotfiles in git and a package list, a rollback takes 2 minutes and the fear of updates goes away. NixOS earns its learning curve when several machines have to stay identical, and on a server I wouldn’t run anything else.

CTF and Forensics Skills That Make You a Better DevOps Engineer

Fri, 27 Feb 2026 19:52:00 +0100

TL;DR I spend my evenings on Hack The Box and it’s made me better at my day job, which is platform engineering and has nothing to do with pentesting. The first ten minutes on a CTF box and the first ten minutes on a broken production server are the same loop, with “flag” swapped for “incident”. Below is the toolkit that loop runs on, from one host up to a Kubernetes pod, with the CTF use and the work use side by side for every command.

Simulation, Emulation, Virtualization, and Containers: The Restaurant Metaphor

Mon, 23 Feb 2026 20:18:00 +0100

TL;DR Simulation models a thing without running it. Emulation runs it by rebuilding the hardware in software. Virtualization runs several complete operating systems on one machine. Containers run several apps on one kernel. Below, one restaurant per term, a table, and the four mix-ups I hear most.

“So what’s the difference between a container and a virtual machine?”

I get this question a lot, usually from someone smart who’s been nodding along in meetings and doesn’t quite want to admit they’re fuzzy on it. The honest answer is that most explanations make it worse. They open with “hypervisor”, “kernel sharing” and “hardware abstraction”, and now the person has four new terms to be confused about instead of one.

Zero Trust Explained: The Hotel Key Card Metaphor

Thu, 19 Feb 2026 21:34:00 +0100

TL;DR The old model is a castle. Get past the wall and you’re trusted everywhere inside. Zero trust is a hotel. Your key card opens your room, the gym if you booked it, and nothing else, and every door checks the card every time. Below, the three principles, a day in that hotel, and what the key card turns into once the doors are software.

“So what is this zero trust thing everyone keeps talking about?”

Learn the Defaults: Why Portability Beats Customization

Sun, 15 Feb 2026 19:47:00 +0100

TL;DR I spent years polishing a vim and tmux setup, then sat useless in front of a stock vim on a production server. So I learned the defaults I’d been overriding all along, and moved my customizations on top of them instead of in place of them. What that looks like for vim, tmux and the shell tools, and the four checks I use to find the gaps.

For years my setup was the thing I was proudest of. A dotfiles repo with commits going back further than some of my jobs, a vim config that pulled in thirty plugins, the tmux prefix moved somewhere comfortable, a prompt that took a weekend to get right. Down to the last keybinding, it was mine. On my laptop I was fast, and I hardly thought about the tools at all. Muscle memory did the work.

Dotfile Management with mise and chezmoi: The Perfect Combo

Wed, 11 Feb 2026 20:23:00 +0100

TL;DR Six ways of syncing dotfiles later, the one I kept is chezmoi for the files and mise for the tool versions, with the mise config living inside the chezmoi repo. Templates handle the work laptop against the personal desktop, age handles the secrets, and a fresh machine is one command and about five minutes. The walk-through goes from one managed file to the bootstrap I run for real.

My .zshrc is older than some of my coworkers’ careers. Same for my .vimrc and my tmux config. They’ve grown into a setup that does exactly what I want, and I’d be lost without them. The catch is that I run more than one machine. A laptop, a desktop, now and then a throwaway VM for testing. For years, keeping those in sync was a pile of hacks I didn’t trust.

Data-Driven Kubernetes Migration: Why You Need Metrics Before You Move

Sun, 08 Feb 2026 14:00:00 +0100

TL;DR An e-commerce client moved a PHP monolith to EKS in October, two weeks before Black Friday, with resource limits guessed from the old server specs. Mid-morning the pods hit their memory limit, died in a loop for four hours, and the estimate was €240,000 in lost revenue. The second half is how to get those numbers from load tests and VPA recommendations instead of guessing them.

“We want to migrate to Kubernetes by November.”

K8sGPT with a Local 70B Model on Apple Silicon

Thu, 05 Feb 2026 14:00:00 +0100

TL;DR I pointed K8sGPT at a Llama 3.3 70B model running on a Mac Studio in my own office, so no cluster metadata leaves the network, and fed it three broken workloads. It found all three and wrote fixes I’d accept from a colleague, except for the resource numbers, which it made up. Assisted diagnosis works, at 25 seconds a query. Autonomous cluster management is still marketing, and the security section is why I wouldn’t let a model change anything on its own.

Why Privacy Matters More Than Ever

Mon, 02 Feb 2026 14:00:00 +0100

Your phone logged where you slept before you woke up. You check Gmail, search something on Google, message a friend on WhatsApp, pay for coffee with a card and walk past a dozen cameras before lunch. None of that feels like surveillance. It feels like a normal morning.

It felt the same five years ago, and I want to show you what changed in between. The comfortable version of privacy, “I have nothing to hide”, has quietly stopped being true, and I think most people haven’t noticed. Three things happened at once. On its own each one is manageable. Together they’re what worries me.

The Hardware Ownership Paradox: When Sovereignty Gets Expensive

Fri, 30 Jan 2026 14:00:00 +0100

In my previous post about self-hosting for everyone I drew a hopeful picture of managed self-hosting, where anyone can own their data. I skipped over something, and it’s been bugging me since. Hardware costs money, and the sum comes out very differently depending on whether a business or a person is paying.

So here are two rules. Both sound reasonable on their own. Then I’ll put them in the same room.

Self-Hosting for Everyone: A Vision for Digital Agency

Tue, 27 Jan 2026 14:00:00 +0100

Most people keep their photos at Google, their mail at Gmail, their documents in whatever cloud came with the phone and their passwords in a browser built by an advertising company. Every byte sits on a server they don’t own, under terms they didn’t read, in a country they didn’t check. Nobody finds that strange anymore, because the alternative looks like a second job.

I want to talk about that alternative, and about why it sits behind a wall most people will never climb.

The space container thought experiment: systems thinking for survival

Tue, 20 Jan 2026 14:00:00 +0100

You wake up. It’s dark. Somewhere a fan is humming.

Your eyes adjust. You’re in a container. Metal walls, a few small windows, and behind them stars. Just stars. No Earth anywhere.

There’s a note taped to the wall:

“You have everything you need to survive. Nothing goes in, nothing goes out. Good luck.”

I bring this one up with friends when the evening has gone quiet enough for it. It sounds like science fiction, and the first reaction is usually a joke about the toilet. Then somebody asks what’s in the room, and we’re off. What the experiment takes away is an assumption I’d never said out loud before I ran it. That there’s an “outside” that absorbs my mistakes and refills my supplies.

When not to use Kubernetes

Sat, 17 Jan 2026 10:00:00 +0100

I write a lot about Kubernetes, and I run it at home every day. I like it.

So it might surprise you that I spend a fair amount of my time talking people out of it.

The situation I keep walking into goes like this. A small team, one product, a roadmap full of features customers are waiting for, and someone has decided the first milestone is a Kubernetes cluster. Three nodes minimum, etcd, a CNI , an ingress controller, cert-manager, a monitoring stack. Weeks of work before a single customer sees anything. Everyone nods along, because that’s what a serious setup is supposed to look like.

YubiKey + Pass + GPG + SSH: One Key to Rule Them All

Tue, 13 Jan 2026 17:00:00 +0100

TL;DR One YubiKey carries a GPG key with a signing, an encryption and an authentication subkey. gpg-agent hands the authentication subkey to SSH, git signs with the signing subkey and pass decrypts with the encryption subkey, so one PIN in the morning and a touch per action replace every password I used to type. The SSH part alone is three steps and worth doing on its own.

Every morning I plug in my YubiKey, type one PIN, and that’s the last secret I type until I pull it out again. SSH to a server, no password. Sign a commit, no passphrase. Pull a secret out of pass, touch the key. One thing in a USB port, and the rest of the day my authentication happens without me.

Pass: the Unix password manager that just works

Sat, 10 Jan 2026 12:00:00 +0100

TL;DR pass keeps each password as a GPG-encrypted file in a directory, and the directory is the whole data model. pass -c email/gmail puts a password in your clipboard from any terminal, pass git push backs the store up, and the fzf script further down is how I look up every password I have. The price is GPG key management, and it’s a real price.

I used KeePass for years. Then 1Password. Then Bitwarden. All decent tools, and every one of them was too much for what I asked of it. Too much UI, too many features, and a password always lived on the other side of an app I had to alt-tab into. A small interruption, and they added up.

GPG explained: from first key to daily use

Tue, 06 Jan 2026 19:00:00 +0100

TL;DR GPG encrypts files and signs things, and it sits under pass, under signed git commits and under the checksums maintainers publish. One command gives you a working keypair in five minutes. Subkeys and a YubiKey come later, if ever, and the UX is bad enough that I complain about it at length below.

GPG is a tool I kept meaning to learn and didn’t, for years. The docs are a wall of text, the terminology is its own dialect, and the error messages are cryptic in both senses of the word.

Taskwarrior, Timewarrior and Vit: The Ultimate CLI Productivity Stack

Sat, 03 Jan 2026 15:00:00 +0100

TL;DR Taskwarrior, timewarrior and vit are my task list, my time tracking and the vim-style screen on top, all in the terminal and all plain text in ~/.task. Two commands get you started. The rest of this post is what I bolted on afterwards, from projects and dependencies to a self-hosted sync server, and you can stop at any section.

For context on how my brain works, see Working with an AuDHD Brain.

Why I self-host everything: on sovereignty, agency and control

Tue, 30 Dec 2025 18:00:00 +0100

For a long time the cloud was just the water I swam in. I provisioned managed Kubernetes, clicked through the console, pasted a Terraform module someone else had written, and shipped. It worked. The bill landed every month, the dashboards stayed green, and I didn’t look underneath. Why would I? I trusted it the way you trust a lift. Press the button, doors open.

Then one afternoon a managed service fell over and I sat there with nothing to debug. No host to SSH into, no log I was allowed to read, nothing underneath it I could open up. The status page said “investigating”. Refreshing a page someone else controlled was the whole of my afternoon.

Working with an AuDHD brain: why I automate everything

Sat, 27 Dec 2025 14:00:00 +0100

For a long time I thought the problem was me.

I have AuDHD , autism and ADHD together. The ADHD is ADHD-PI, the inattentive kind, without the hyperactivity most people picture when they hear the word. For years I treated the whole thing as a defect I’d train away. I bought the planners. I read the productivity books. Every week I told myself that Monday I’d finally be disciplined.

Unbreakable - My Fascination.

Tue, 23 Dec 2025 20:00:00 +0100

As a kid I called the things that fascinated me unbreakable. Indestructible never fit, because indestructible means it never breaks. Unbreakable means it keeps working after it breaks.

I know exactly when it started. A photo of an A-10 Thunderbolt II back from a mission with half a wing gone, the tail in tatters and the fuselage full of holes. It still brought its pilot home.

Luck had nothing to do with it. Somebody sat at a drawing board years before that mission and decided the plane had to come home looking like that.

Prometheus and Thanos: Metrics at Scale

Sun, 31 Aug 2025 10:00:00 +0200

TL;DR Prometheus on its own keeps a couple of weeks of metrics on local disk and can’t answer a question across clusters. Thanos puts a sidecar next to each Prometheus, ships the blocks to object storage, and puts a querier in front that reads all of it back through the same PromQL. Below is the install, the four components, the HA and multi-cluster wiring, and the numbers I run in production.

Kubernetes RBAC: Least Privilege in Practice

Tue, 19 Aug 2025 10:00:00 +0200

TL;DR Kubernetes ships with a permission model that hands every pod a token and lets the default service account collect rights nobody remembers granting. Least privilege means a service account per workload, no token unless the app talks to the API, and roles that name the namespace, the resource and the verb. Below are the four RBAC resources, the five settings that cap the blast radius, the bindings I copy most often, and how I check and enforce all of it.

Runtime Security with Falco: Detect Suspicious Behavior in Your Cluster

Thu, 07 Aug 2025 10:00:00 +0200

TL;DR Trivy and Kyverno check an image before it runs. Falco watches what the container does after that, syscall by syscall, and alerts when the behaviour doesn’t match a rule. This post goes from the one thing Falco does to the config I run, with the noise problem in between.

I scanned my images with Trivy. I enforced policies with Kyverno. My workloads got cryptographic identity through SPIFFE. Three layers of prevention, all green, and for a while that felt like enough.

SPIFFE and SPIRE: Zero Trust Service Identity

Sat, 26 Jul 2025 10:00:00 +0200

How does Service A know that Service B is actually Service B?

I keep coming back to that question because the usual answer is uncomfortable. For years we trusted network location. Traffic from the right IP was legitimate, end of story. Zero trust took that assumption out back and shot it. Now every service has to prove who it is, every single request, no matter where it sits on the network.

Kyverno Policies: Governance as Code for Kubernetes

Mon, 14 Jul 2025 10:00:00 +0200

I used to keep a wiki page titled “Cluster conventions”. Resource limits on everything. No :latest tags. No deploys in the default namespace. It was a good page. Nobody read it. Six months in, half the cluster broke those rules and I only found out when something fell over.

A rule that lives in a doc is a suggestion. A rule the API server refuses to accept is governance. That gap is the whole reason this post exists.

Vault for Beginners: Secrets Management in Kubernetes

Wed, 02 Jul 2025 10:00:00 +0200

The first time I ran kubectl get secret myapp -o yaml and base64-decoded the value, I felt my stomach drop. There was my database password, sitting in etcd, readable by anyone who could reach the API with the right RBAC. Kubernetes Secrets are not secrets. They’re base64-encoded plain text with a fancy name. That’s the default, and it’s the thing nobody warns you about on day one.

Every cloud provider has a fix for sale. AWS has Secrets Manager, Google has Secret Manager, Azure has Key Vault. They work. The catch shows up later: the day you need to migrate, the day you want to know exactly what happens to a secret after you write it, the day you realise your most sensitive data lives in a system you can’t inspect.

Progressive Delivery with Argo Rollouts: Canary and Blue-Green Deployments

Fri, 20 Jun 2025 10:00:00 +0200

A standard Kubernetes Deployment had served me well for a long time. Push a new image tag, watch the pods roll, done. It was simple, it was declarative, and most of the time nothing went wrong. The rolling update even gave me a warm feeling of safety: old pods only get torn down once new ones are ready.

That feeling is a lie. A rolling update protects you from pods that fail to start. It does nothing to protect you from pods that start perfectly and then serve broken responses. The container is healthy, the readiness probe is green, and your new code is quietly returning 500s to every single user. Within seconds, 100% of your traffic is hitting code that nobody validated under real load.

Container Image Scanning with Trivy in Your CI Pipeline

Sun, 08 Jun 2025 10:00:00 +0200

Pull a base image, copy in your code, push it to production. That’s the loop most of us run on autopilot. The part nobody looks at is the base image itself, which quietly drags in a few hundred packages you never chose. Any one of them could carry a known CVE , and you’d have no idea.

Automating Semantic Versioning with GitLab CI

Tue, 27 May 2025 19:44:00 +0200

Picture the end state first. You merge a branch to main, walk away to get coffee, and by the time you’re back the project has a new version tag, a fresh changelog entry, and a GitLab release with notes written from your commits. Nobody decided “is this 1.4.0 or 1.3.5?” because nobody had to. The version fell out of the work itself.

That’s where I want to get to in this post. I run a self-hosted GitLab and I do not want versioning to be a thing I think about. A version number that someone picks by hand is a tiny black box: it depends on whether that person remembered the rules, was paying attention, and agreed with everyone else about what counts as a breaking change. I would rather the number be a consequence of the commits, something I can inspect and reproduce.

GitLab CI for Kubernetes: From Commit to Deployment

Thu, 15 May 2025 20:33:00 +0200

For a long time my CI lived on someone else’s servers. Push code, wait for a hosted runner, watch the minutes tick down against a monthly quota, hope the provider doesn’t change the rules next quarter. It worked, right up until I started asking where my source code actually sat while it was being built, and who else could see it.

So I moved GitLab in-house. I run it self-hosted now, on my own hardware, next to the clusters it deploys to. That’s sovereignty applied to CI/CD: my code, my builds, my artifacts, no vendor that can change pricing, deprecate a feature I depend on, or read my repositories without me knowing.

Drift Detection with ArgoCD: How to Know If Your Cluster Is Still in Sync

Sat, 03 May 2025 19:27:00 +0200

The whole pitch of GitOps is that Git is the source of truth. That promise holds right up until someone runs kubectl edit on a deployment at 2am to stop an incident, a mutating webhook quietly rewrites a resource, or a half-finished sync leaves your cluster somewhere between what Git wanted and what it got. Now Git says one thing and the cluster does another, and nobody told you.

That gap is configuration drift, and it is the part of GitOps people forget to defend. The good news: ArgoCD already watches for it. The catch is that the defaults don’t do what you probably assume, and a few of them will bite you. This post walks from the simplest possible drift check up to the setup I actually run, one layer at a time. Stop wherever you have enough.

App-of-Apps Pattern in ArgoCD: Scalable GitOps Architecture

Mon, 21 Apr 2025 20:18:00 +0200

My homelab started with one ArgoCD Application. Then a handful. The day I caught myself running kubectl apply -f for the fifteenth time to register yet another Application, I knew I’d built the exact thing I was trying to avoid: manual steps I had to remember, in an order I had to remember, with no record of what should exist.

The App-of-Apps pattern fixes that with one idea. You create a single root Application by hand, and it creates everything else. After a cluster wipe I can rebuild the whole thing with one kubectl apply. That property is the entire reason I run it, and it’s the same reason I self-host in the first place: I want the repository to be the truth, not my memory.

GitOps Disaster Recovery: Rebuilding Your Cluster from Git

Wed, 09 Apr 2025 19:52:00 +0200

For a couple of years my homelab cluster ran without much drama. Nodes came and went, workloads shifted around, and the worst I ever had to deal with was the occasional pod stuck in CrashLoopBackOff. The kind of stable where you stop thinking about what happens if it all goes away.

Then one evening I ran a terraform destroy against the wrong workspace. By the time I noticed, the control plane was gone. Not degraded. Gone.

ArgoCD vs Flux: When to Choose What

Fri, 28 Mar 2025 21:33:00 +0200

“Should I use ArgoCD or Flux ?”

I get this question over coffee, in Slack, in PR comments, probably once a week. People want me to declare a winner so they can stop thinking about it and go build something.

Here is my bias, up front, so you can weigh everything that follows: I run ArgoCD on my own clusters. I have a few years of it under my belt and I like it. That preference is going to leak through no matter how careful I am, so I am telling you now instead of pretending I am neutral.

ArgoCD for Beginners: Your First GitOps Deployment

Sun, 16 Mar 2025 19:15:00 +0100

Here is the thing I never want to do again: ask a cluster what it is running and not trust the answer. For years that was normal. Someone ran kubectl apply, maybe from a laptop, maybe from a CI job nobody could find anymore, and the live state slowly drifted away from anything written down. When I switched to GitOps, that whole category of uncertainty disappeared. I push to Git, and the cluster converges to match. If I want to know what is deployed, I read a file.

Running Kubernetes Offline: Edge Computing Without Internet

Tue, 04 Mar 2025 20:47:00 +0100

What happens when your Kubernetes cluster can’t reach the internet? I don’t mean a slow connection. I mean no connection at all. Ships at sea. Remote mining sites. Factory floors with air-gapped networks. Military deployments.

For a lot of people that sounds exotic, like a problem someone else has. I treat it as a baseline design requirement, and I’ll explain why it makes my homelab better even though I almost never actually pull the cable.

Graceful Degradation in Kubernetes: What Happens When Components Fail

Thu, 20 Feb 2025 14:22:00 +0100

Everyone repeats the line that Kubernetes is self-healing. Pods die, they come back. Nodes drop, workloads reschedule. The system reconciles itself toward the state you declared, and most days you never have to think about it.

Then one day the thing doing the healing is the thing that broke. The API server is down. etcd won’t respond. The scheduler is wedged. Now what?

This is the question I actually care about, because “self-healing” is only useful if I understand its edges. I want to know what degrades gracefully and what takes the whole cluster with it. So I’ve run my clusters through a lot of failures on purpose: planned, unplanned, and a few “hold my beer” experiments on hardware I didn’t mind losing. Here is what actually happens when each piece breaks, and why most of it matters less than people fear.

Kubernetes Network Policies: A Visual Guide to Pod Security

Sat, 08 Feb 2025 19:34:00 +0100

Picture this: an attacker pops a single pod in your cluster, maybe through a vulnerable image or a leaked token. From that one foothold, they can reach every database, every internal API, every secret-fetching sidecar you run. Nothing stops them, because by default nothing tries to.

Network Policies are the thing that stops them. They turn “one compromised pod” into “one compromised pod, and that’s it.” Everyone knows they should use them. Almost nobody actually does, because the YAML looks scary and the behaviour is weird until the mental model clicks.

How etcd Actually Works: The Heart of Your Kubernetes Cluster

Mon, 27 Jan 2025 21:47:00 +0100

When something goes wrong in Kubernetes, the trail usually leads back to etcd. API server timing out? Check etcd. Pods stuck in pending? Might be etcd. Cluster feels sluggish? Probably etcd.

For a long time I treated etcd the way most operators do: as a black box that hums along next to the control plane. “The database.” You back it up and otherwise leave it alone. But black boxes feel like splinters to me, and the first time an etcd cluster fell over at 2am I realised I had no idea what I was actually looking at. So I learned. And it turns out the whole thing is built on a handful of ideas that, once they click, make most etcd problems diagnosable instead of terrifying.

Kubernetes High Availability: Stacked vs External etcd Explained

Wed, 15 Jan 2025 20:23:00 +0100

The first “production” Kubernetes cluster I ran had a single control plane node. It hummed along happily for weeks, right up until a disk failed and took the whole thing with it. Every pod, every service, gone. That outage taught me what “single point of failure” actually feels like, and it pushed me toward a question that I keep seeing trip people up: when you build a cluster that survives node loss, do you run etcd on your control plane nodes, or on dedicated nodes of its own?

Mon, 01 Jan 0001 00:00:00 +0000

Start here