Running the reference, start to finish.
From a bare Fedora workstation to a fully running data mesh — kernel tuning, tooling, and a single bootstrap command that brings up the entire stack: Istio, Kafka, Postgres, OpenMetadata, observability, and every domain service.
Verified configuration
| Requirement | Minimum | Notes |
|---|---|---|
| OS | Fedora 44, Docker Engine (docker-ce, daemon running, user in docker group) | minikube node runs containerd with runc |
| RAM | 64 GB total | 24 GB allocated to minikube profile; rest is host headroom |
| Disk | 1 TB | About 100 GB free under the Docker data root (/var/lib/docker) |
| CPU | 16 vCPU recommended | Not strictly required but the stack is heavy |
Kernel tuning
inotify limits
The capstone runs many controllers; Fedora's default 128 instances is not enough.
sudo sh -c 'printf "fs.inotify.max_user_instances = 512\nfs.inotify.max_user_watches = 524288\n" \
> /etc/sysctl.d/99-kubernetes.conf'
sudo sysctl -p /etc/sysctl.d/99-kubernetes.conf
Container engine
The capstone runs on Docker Engine: native docker-ce on Linux,
with the daemon running and your user in the
docker group. Install it from
docs.docker.com/engine/install,
then enable it and point the CLI at it:
sudo systemctl enable --now docker # or: sudo systemctl start docker
sudo usermod -aG docker "$USER" # log out and back in afterwards
docker context use default
docker info
Membership in the docker group is root-equivalent on the host.
VM-based engines
The capstone scripts are supported on Fedora and RHEL hosts (bare metal
or VM). A VM-based engine such as Docker Desktop can provide the engine instead. It
is an option, not a requirement. Its VM must be sized to at least 28 GB of memory;
set MINIKUBE_CPUS and MINIKUBE_MEMORY to
fit it, as described below.
Upgrading from an earlier (rootless podman) capstone profile
An earlier release created the profile with rootless podman. Delete that profile first, then clear the setting, then run setup:
MINIKUBE_ROOTLESS=true minikube delete -p capstone
minikube config unset rootless
./scripts/setup-capstone-profile.sh
Fitting minikube to the engine
The profile defaults to 16 CPUs, 24 GB of memory, and an 80 GB disk. Override them before creating the profile:
export MINIKUBE_CPUS=16
export MINIKUBE_MEMORY=24g
export MINIKUBE_DISK=80g
The docker driver on Linux ignores the disk size; data lives under
the engine's data root (docker info shows it), where
about 100 GB free is recommended.
Required tooling
- docker and docker compose (compose is not used by the minikube path; listed as a standard host tool)
- minikube >= 1.39.0 — the profile pins Kubernetes v1.36.5
- kubectl 1.36.x
- helm
-
istioctl 1.31.1 — with the full Istio
distribution (not just the binary;
setup-kiali.shappliessamples/addons/kiali.yamlfrom it)
Optional, for the Red Hat (OpenShift Local) appendix only: crc, podman, and podman compose.
Installing the Istio distribution
curl -fsSL https://github.com/istio/istio/releases/download/1.31.1/istio-1.31.1-linux-amd64.tar.gz \
| tar xz -C ~/.local/share
ln -sfn ~/.local/share/istio-1.31.1 ~/.local/share/istio-current
cp ~/.local/share/istio-current/bin/istioctl ~/.local/bin/
Bootstrap
Bring the whole system up
cd examples/lgtm-datamesh
./scripts/bootstrap-capstone.sh
Images are built with Docker Engine and loaded into the node with
minikube image load; there is no registry. Bootstrap runs 10 tiers: minikube profile, Istio,
CloudNativePG operator, Postgres cluster, Kafka (Strimzi),
KEDA + HTTP add-on, OpenMetadata + observability, all services +
scalers + seed data, Kiali, and catalog ingestion + lineage.
Restore baseline after running demos
./scripts/restore-baseline.sh
The demo scripts clean up their own releases on success. After
running several, shared services may be missing.
restore-baseline.sh puts the workloads back in
their bootstrap state.
Verifying the stack
Cluster status
./scripts/cluster-status.sh
Quick verification demos
-
./demos/demo-order.sh— creates an order via REST, confirms it in Postgres -
./demos/demo-service.sh inventory— builds, deploys, and health-checks a service -
./demos/demo-observability.sh— verifies Prometheus is scraping and Grafana is provisioned
Accessing the tools
The tools run inside the cluster and are exposed as NodePort
services published on 127.0.0.1 when the
capstone minikube profile is created. Nothing runs in
the background and nothing needs starting per demo. Ports are
fixed at creation; an older profile without them is refused by
setup-capstone-profile.sh and recreated with
./scripts/setup-capstone-profile.sh --replace.
--replace deletes and recreates the cluster, so run
./scripts/bootstrap-capstone.sh again afterwards.
Run the workshop in isolation: shut down CRC, other minikube
profiles, and other workloads first so the host ports are free.
To see which endpoints are published and reachable:
./scripts/show-endpoints.sh
(Prometheus uses host port 9091 because Fedora ships Cockpit on 9090.)
| Tool | Local URL |
|---|---|
| Grafana | http://127.0.0.1:3000 |
| Prometheus | http://127.0.0.1:9091 |
| Kiali | http://127.0.0.1:20001/kiali |
| Tempo (via Grafana) | — (Grafana → Explore → Tempo datasource) |
| OpenMetadata | http://127.0.0.1:8585 |
| Apicurio | http://127.0.0.1:8084 |
| Kafka UI | http://127.0.0.1:8089 |
Grafana default credentials are admin / the value
from
kubectl get secret grafana -n capstone -o jsonpath='{.data.admin-password}' | base64 -d.