CNCF Ambassador, Google Developer Expert, Grafana Champion, co-host of Plattformpodden, platform engineer in the Norwegian government. Has broken enough production clusters to know how to build good ones.
Cloud on Your Terms: Building Your Own Cloud-Native Platform
– Workshop B
Foredragsholdere
Øyind Randa
Software Architect at NextGentel, Lead Organizer for GDG Bergen. Knows his way around distributed systems and has opinions about YAML.
Om sesjonen
What if your cloud provider jacks up prices tomorrow? What if your government says your
data can't leave the country? What if the software your platform depends on gets
relicensed out from under you?
Good news: you can build your own platform. We'll do it in four hours, using only
open-source cloud-native tools, and you'll leave with something that actually runs — on
your own laptop, entirely offline — not just a slide deck.
## What we're building
Think of it as a "cloud in a box" — a self-hosted platform that gives your developers
everything they need, without anyone's permission:
- A **Kubernetes cluster** on Talos Linux (immutable, API-driven, no SSH — yes, really)
- **eBPF networking** with Cilium — you install the CNI yourself and watch the cluster
come alive (there's no kube-proxy either)
- **GitOps delivery** with ArgoCD v3 — pointed at your cluster's *own* git server
(in-cluster Gitea), because your platform shouldn't depend on GitHub being up
- **PostgreSQL-as-a-Service** via CloudNativePG
- **S3-compatible object storage** via RustFS (an open-source, Apache-2.0 alternative
to MinIO, whose open-source edition was discontinued — a story we'll come back to)
- **Self-service infrastructure** with Crossplane v2 — one YAML claim, and an app
appears with its database and bucket wired in
- **Serverless** with Knative — services that scale from zero while you watch
- **CI on your terms** with Argo Workflows + BuildKit + a Zot registry — your cluster
builds its own images, no external CI touched
- **Durable messaging** with NATS JetStream
- **A cloud console you can actually read** — a real portal whose entire source ships
in the repo (plus a Backstage demo for the enterprise-sized version)
- **Observability** with OpenTelemetry and the VictoriaMetrics stack, fronted by
Grafana — your uploads traced end to end
That's a lot for four hours, and we won't go deep on every tool — the labs state
outcomes, not steps, and layered hints keep you moving. Along the way you'll also break
things on purpose and debug them (with or without an AI assistant — and learn why you
should double-check what it tells you).
## The ending is yours
The last hour is a choose-your-own-adventure: pick the door that matches why you came —
**app dev** (build a real service on your platform), **platform** (add a capability
yourself: cert-manager, or Kafka if your laptop is beefy), **security** (zero-trust
network policy against a live pipeline, image signing), or **infra** (Talos surgery,
etcd backups, Gateway API). The doors are open-ended by design: start in the room,
finish on the couch — the platform goes home with you and runs without internet.
## Before you come
**Do the prework.** It downloads ~7.5 GB of container images; conference WiFi will not
save you. You'll need Docker and a laptop with 16 GB RAM (32 GB recommended). Prior
Kubernetes experience helps but isn't required. Setup instructions:
https://github.com/randax/Platform-Engineering-Workshop
Passer for
Developers, Architects, Sysadmins, DevOps
Forberedelser
Do this *before* the workshop. Seriously. The setup downloads ~7.5 GB of container images — conference WiFi carries keystrokes, not gigabytes. After these steps, the entire workshop runs offline on your laptop. 1. Clone the repo: ```bash git clone https://github.com/randax/Platform-Engineering-Workshop.git cd Platform-Engineering-Workshop ``` 2. Install the pinned tools (uses [mise](https://mise.jdx.dev/) for version management — say yes when it offers to hook into your shell; it also gives you a workshop-only kubeconfig so your real clusters are never touched): ```bash ./scripts/dev-setup.sh ``` 3. Pull the container images (go make coffee, this takes a while): ```bash ./scripts/cloudbox-init.sh ``` 4. Verify everything works: ```bash ./scripts/install.sh --check ``` If step 4 prints all green, you're done. If it won't go green and the output can't help you fix it, the repo ships a devcontainer/Codespaces lifeboat with the exact same workshop content — see "Plan B" in the README. One more thing: re-run steps 3–4 in the last day or two before the workshop — the image list gets its final refresh about two days ahead, and a re-run only pulls what's new. Hardware — honest numbers: 16 GB RAM minimum (32 GB recommended, and close your Electron zoo on 16), 4 CPU cores, 40 GB free disk, Docker running (macOS: OrbStack or Docker Desktop with a raised memory limit; WSL2: raise the limit in .wslconfig). macOS and Linux fully supported; Windows/WSL2 is best-effort — if it fights you, the lifeboat has you covered. Bring your power supply. Prior Kubernetes experience helps but isn't required — the labs state outcomes and walk you there with layered hints. AI assistants are welcome, as tutors: the repo will coach them to help you learn rather than do the labs for you ## Further reading - [CNCF Landscape](https://landscape.cncf.io/) — the full map of cloud-native projects - [Platform Engineering Roadmap](https://roadmap.sh/devops) - [Kubernetes Docs](https://kubernetes.io/docs/) - [GitOps Principles](https://opengitops.dev/)