See every principle, live.
23 scripts under examples/lgtm-datamesh/demos/
exercise the data-mesh reference end to end. Each one is mapped
to the principle it demonstrates — domain ownership, data as a
product, self-serve platform, or federated governance.
The five-act walkthrough
walkthrough.sh orchestrates five acts — trace,
scale, canary, lineage, topology — each shelling out to an
existing demo script with narration between them. Press Enter
to advance between acts.
cd examples/lgtm-datamesh && ./demos/walkthrough.shDemos by principle
Domain ownership
These demos verify that each domain service owns its data, its API surface, and its operational lifecycle — independent build, deploy, and verification.
Order-service walking skeleton
Full spine: image build, helm deploy, operator-managed Postgres, REST round-trip. Creates an order and confirms it in the database.
Cross-service gRPC
order-service calls inventory-service CheckStock over gRPC. Proves domain isolation with clear API boundaries between data products.
Generic service health
Build, deploy, and verify health for any scaffolded service. Proves the common domain template works end to end.
Data as a product
These demos exercise the contract, catalog, and discovery surfaces that make each domain's data discoverable, addressable, and trustworthy.
Avro contracts (schema registry)
order-service registers an Avro schema in Apicurio; notification-service decodes by schema ID. The contract is the schema, not a handshake.
Discovery contracts published
Publishes OpenAPI, Protobuf, GraphQL SDL, and Avro to Apicurio — the feedstock for the catalog.
Federated read layer (GraphQL)
One query to the gateway stitches order (REST) and stock (gRPC) into a single response. The composed read surface of the mesh.
Review-service data product
Builds and verifies the review-service REST surface end to end — a standalone data product with its own schema.
Add/remove a data product
Full add-to-mesh workflow: deploy, publish contract, ingest catalog, then clean rollback. The mesh grows by one product.
OpenMetadata catalog health
Verifies the catalog server is deployed, healthy, and backed by Postgres — the discovery surface the mesh depends on.
Cross-product lineage
Proves the lineage graph: orders table, order-placed topic, notifications table. Data flows are visible, not guesswork.
Self-serve data platform
These demos show the platform delivering capabilities by declaration — operators provision databases, message buses, and autoscalers; the observability stack surfaces metrics, traces, and topology.
Async spine (Kafka events)
order-service publishes order.placed; notification-service consumes it. The Strimzi operator delivers the Kafka cluster by declaration.
Durable notifications (Postgres)
Alembic migration, persisted events, survives restart. The CloudNativePG operator delivers the database by declaration.
Kafka consumer-lag scaling
notification-service scales from zero on Kafka lag, then back to zero when caught up. Elastic data products by declaration.
HTTP request scaling (KEDA)
graphql-gateway scales from zero on HTTP request concurrency via the KEDA HTTP add-on. Zero cost when idle, instant wake on demand.
Metrics stack health
Prometheus scraping capstone targets, Grafana dashboard provisioned with mesh and request-rate panels. The platform delivers observability.
Trace backend health (Tempo)
Tempo up, Grafana datasource wired, synthetic span ingested and queried back. The trace pipeline works before you send real traffic.
End-to-end trace across products
A GraphQL query fans out to three services; the trace lands in Tempo with cross-product spans. Distributed tracing as a platform feature.
Federated computational governance
These demos exercise the governance mechanisms — mTLS, progressive delivery, and mesh topology — that keep independently-owned products interoperable.
Canary contract evolution (verified)
v1 and v2 both meshed; traffic splits by VirtualService weight. Asserts the 90/10 and 50/50 splits land in expected bands.
Canary demo (repeatable)
Presenter-facing: bring the canary up at a chosen weight, shift it, tear it cleanly back to v1-only baseline. Fully replayable.
Kiali mesh topology
Kiali API answers, Prometheus reachable, capstone namespace visible in the graph. The mesh is observable as a first-class surface.
Running a demo
All demos assume you are in the
examples/lgtm-datamesh/ directory with kubectl
context set to capstone. See the
setup & prerequisites
page for installation and bootstrap.
cd examples/lgtm-datamesh
./demos/demo-order.shWhat to look at after running a demo
The tools are NodePorts published on 127.0.0.1 when
the capstone profile is created, so the URLs below
are available as soon as the stack is up. Run
./scripts/show-endpoints.sh to see which are
reachable. Ports are fixed at creation; recreate an older profile
with ./scripts/setup-capstone-profile.sh --replace.
--replace deletes and recreates the cluster, so run
./scripts/bootstrap-capstone.sh again afterwards.
-
Grafana — dashboards for request rate,
canary weight, KEDA replicas:
http://127.0.0.1:3000 -
Kiali — live mesh topology graph:
http://127.0.0.1:20001/kiali -
Tempo — distributed traces: open Grafana
→ Explore → select the Tempo datasource
(or direct:
http://127.0.0.1:3200) -
OpenMetadata — catalog and lineage:
http://127.0.0.1:8585
Restoring baseline
The demo scripts clean up their own releases on success. After running several, shared services may be missing. To put the workloads back in bootstrap state:
./scripts/restore-baseline.sh