The OpenChoreo platform demo
A fully realized OpenChoreo installation on one machine: how well it standardizes CI, CD and observability across applications. Start with the walkthroughs.
Walkthroughs
Each one is a path through the console, with screenshots of the real thing. They are the same files the console serves at /guides.
| Setting up a new project | From nothing to a running component, by CLI or by preview, and what happens after. |
| Finding your way around | The three views of the estate, and which question each one answers. |
| Down to the Kubernetes manifest | From a project to the actual objects, their YAML, their events and their logs. |
| What changed, and where it went | Commits, diffs, builds, test reports and the promotion trail. |
| Is it healthy, and where did the time go | Project 360, transactions, CPU profiles, and the differences between environments. |
| Every page has a JSON twin | The API behind the console, and the one rule it follows. |
| A worker was OOMKilled — is it a leak or a limit | The runbook the PodOOMKilled alert links to. Tell a leak from a limit that is merely too low, then find which job is holding the memory. |
| Profiles and flame graphs, in CI and in production | Where profiles come from, which questions each kind answers, and how to read a flame graph without being misled by it. |
| Three kinds of slow, and which tool sees each one | A profile, a trace and a memory graph answer different questions. Four endpoints that are all "slow" and all need a different instrument, with the query for each. |
| How big is a workload — size classes | What small, medium, large and xlarge mean, why they are different absolute numbers for a Rails service and a static site, and where to set one. |
| From a push to production, in one commit | The whole delivery path — build, release, promote — and where each step is answerable. Includes why a build can produce more than one release. |
| A pull request gets its own environment | What a review environment is, why it is a dev tier rather than a copy of staging, what it costs, and what happens to it when the pull request closes. |
| When the platform refuses, and how to tell why | Four different refusals — a commit lock, capacity, a deploy window, a gate — and why each one is a sentence rather than a greyed-out button. |
| Two environments, side by side | What differs between staging and production, told two ways — what was declared, and what is actually running — plus why a two-sided diff is useless here. |
| A construct changes underneath you | Component types and traits are versioned objects with consumers. What happens when one moves, how to see what adopting a version would change, and why your release was re-cut without you asking. |
| From a template to a running service | The golden paths this platform offers, what a scaffold actually writes, and how to see the difference between "nothing customised" and "customised". |
| Following one request across six services | A trace, what it is joined to, and the three places a trace stops being useful — with what to reach for instead. |
| An alert fired — what to read, in what order | Where alerts come from, why each one carries a runbook, and how to get from a firing alert to the log line and the commit behind it. |
| What the tests and the build cache actually say | Test reports as a platform standard rather than per-language luck, and reading a cache verdict without fooling yourself. |
| Who owns this, what may I do, and where are its docs | The three questions that are not about running code — ownership, permissions and documentation — and where each is answered honestly. |
| A database is part of the environment, not a footnote | Backing services as first-class objects — how they are declared, why they move by release rather than by commit, and the two ways they bite. |
Reference
The manuals. Access, changing things, observability, versioning, testing, secrets.
| The installation | What is running on this machine, and how it was built |
| Getting at it | Every UI, credential, CLI and API, and which names are public |
| Changing things | I want to change X: the task-shaped guide |
| Observability | Logs, traces, metrics and profiles, and why one stack |
| Versioning | How platform constructs and internal libraries are versioned |
| Test reports | The contract every language implements |
| Secrets | Application secrets, CI secrets, and the cross-cluster path |
| Storage | What holds what, and the retention that actually binds |
| The walkthrough bot | What it exercises, and how to run one |
| A version moving | A construct version rolling out, as it happened |
| Two environments | Staging beside production, as it happened |
The record
Append-only. Not documentation -- the reasoning behind nearly everything above, kept because the why outlives the what.
| Feedback, round by round | What was asked for, and what it turned out to be |
| Findings | Eighty-odd of them, each with the evidence |
| The standing brief | What is built, and what is not |