Open Source · Zero Boilerplate

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.

Get started GitHub

10 lines vs 400+

hello-website/katalog.yaml
Complete operator · 10 lines

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 }}"

controllers/website_controller.go
~400 lines — and growing

// 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
}

< 1 hour first operator

~79 MB 10 CRDs, one runtime

0 lines of Go required

100% declarative

Built-in observability

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.

controlcenter.orkestra.sh

platform-operator ● Healthy

4CRDs

16Workers

247Resources

0Errors

database ● Healthy · 4 workers

Queue: 3/64 · Uptime: 48h

application ● Healthy · 4 workers

Queue: 2/64 · Uptime: 47h

cache ⚠ Pending · 0 workers

Waiting for: database

ingress ● Healthy · 4 workers

Queue: 1/64 · Uptime: 48h

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 — 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.

Live Control Center Read the docs

Real operators are complex

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, endpoint written automatically
Drift correction — reconcile: true keeps resources in sync
Resync interval — periodic reconciliation out of the box

Learning to Orkestrate

katalog.yaml

spec:
  crds:

    network:
      workers: 2

    database:
      workers: 5
      dependsOn:
        network:
          condition: healthy

    application:
      workers: 3
      dependsOn:
        database:
          condition: healthy

What you get for free

Everything 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.

Katalog schema

Zero Boilerplate

No informers, workqueues, RBAC manifests, or controller-manager setup. Orkestra generates and manages all of it from your Katalog.

Quick start

Security Built-in

Deletion protection, namespace restrictions, admission webhooks, and minimal RBAC derived directly from your Katalog — no separate security layer to configure.

Security docs

Drift Correction

Mark any managed resource with reconcile: true — Orkestra detects and corrects configuration drift on every reconcile cycle.

OperatorBox schema

Status Propagation

Declare status fields as template expressions. Orkestra evaluates and writes them after every successful reconcile — no custom code needed.

Status schema

Motif & Komposer

Compose reusable Motifs into Katalogs. Assemble full platform control planes from building blocks via the Orkestra Registry.

Orkestra Registry

The workflow

From 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
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.

Kubernetes operators.Without the Go.