Kubernetes operators.
Without the Go.
Write a YAML file. Get a production-grade Kubernetes operator — with built-in reconciliation, drift correction, status propagation, and full observability.
apiVersion: orkestra.orkspace.io/v1
kind: Katalog
metadata:
name: hello-website
author: orkspace
version: 0.1.0
description: One CRD. One Deployment. Full operator.
spec:
crds:
website:
crdFile: my-website.yaml
operatorBox:
default: true
onCreate:
deployments:
- image: "{{ .spec.image }}"// This is just the Reconcile function.
// You still need: main.go, types, RBAC,
// CRD schema, Dockerfile, Helm chart...
func (r *WebsiteReconciler) Reconcile(
ctx context.Context,
req ctrl.Request,
) (ctrl.Result, error) {
website := &appsv1.Website{}
if err := r.Get(ctx, req.NamespacedName, website); err != nil {
return ctrl.Result{}, client.IgnoreNotFound(err)
}
deploy := r.buildDeployment(website)
existing := &appsv1.Deployment{}
err := r.Get(ctx, types.NamespacedName{
Name: deploy.Name, Namespace: deploy.Namespace,
}, existing)
if errors.IsNotFound(err) {
if err := r.Create(ctx, deploy); err != nil {
return ctrl.Result{}, err
}
} else if err != nil {
return ctrl.Result{}, err
} else {
existing.Spec = deploy.Spec
if err := r.Update(ctx, existing); err != nil {
return ctrl.Result{}, err
}
}
// update status, handle finalizers,
// emit events, set owner refs...
// 300+ more lines
return ctrl.Result{}, nil
}Control Center — one dashboard for every Orkestra runtime
The moment you run ork run, a live dashboard starts on port 8081 — showing every CRD, worker, queue depth, and reconcile event in real time. No extra setup.
Multi-runtime aggregation
Monitor every Orkestra instance — across clusters, namespaces, or environments — from a single Control Center.
Per-CRD drill-down
Click any CRD to see worker pool depth, queue pressure, admission stats, version conversion metrics, and live CR instances.
Zero configuration
Control Center is built into the ork CLI. Launch it with ork control start — no additional binary or Helm chart needed.
Live production visibility
See a running Control Center connected to a live Orkestra cluster — watch real operators, real CRs, real events.
Multiple CRDs, dependencies, status — still just YAML
Most real operators manage several related resources with startup ordering and status propagation. Orkestra handles all of it from a single Katalog file.
- Dependency ordering — database starts before application
-
Status propagation —
phase,endpointwritten automatically -
Drift correction —
reconcile: truekeeps resources in sync - Resync interval — periodic reconciliation out of the box
apiVersion: orkestra.orkspace.io/v1
kind: Katalog
metadata:
name: platform-operator
version: 1.0.0
spec:
crds:
# ── CRD 1: no dependencies, starts first ──
database:
crdFile: my-database.yaml
resync: 30s
operatorBox:
onCreate:
deployments:
- image: "postgres:{{ .spec.version }}"
reconcile: trueEverything a production operator needs
One runtime. Every CRD pattern. No boilerplate.
Declarative CRDs
Define your API schema in YAML. Orkestra auto-generates the CRD, registers it with the API server, and starts reconciling immediately.
Learn moreZero Boilerplate
No informers, workqueues, RBAC manifests, or controller-manager setup. Orkestra generates and manages all of it from your Katalog.
Quick startDrift Correction
Mark any managed resource with reconcile: true — Orkestra detects and corrects configuration drift on every reconcile cycle.
Dependency Ordering
Declare dependsOn between CRDs. Orkestra builds the dependency graph and starts each controller only when its dependencies are ready.
Status Propagation
Declare status fields as template expressions. Orkestra evaluates and writes them after every successful reconcile — no custom code needed.
Learn moreComposition at Scale
Combine patterns from Git, OCI registries, and Helm charts using Komposer. Build multi-team platforms from reusable building blocks.
See guidesFrom zero to operator in three steps
Write your Katalog
Define the CRD schema, the resources it manages, lifecycle hooks, and status fields — all in a single YAML file. No Go required.
Run the Orkestra CLI
ork run --file ./katalog.yaml
Orkestra registers the CRD, starts the controller, and launches Control Center automatically.
Orkestra manages everything
Apply a CR and watch Orkestra reconcile child resources, emit events, update status conditions, and self-heal on drift — all from your YAML declaration.