Orbit Plane and Cluster Plane
By Raj Marni. March 23, 2025. Revised. Version: 0.1.01
This document presents Layer 1 high-level, narrative-style explanation of the two planes—Orbit Plane and Cluster Plane. This should help you convey the architecture clearly in discussions or documentation. This is Layer One technical documentation and explains Orbit Plane and Cluster Plane fits into the bigger architectural picture.
The Cluster Plane is a set of short-lived K8s clusters, ideal for dynamic workloads, testing, or staging environments.
The Orbit Plane is the persistent “control center” that orchestrates every aspect of these clusters’ lifecycle, providing security, consistency, and automation at scale.
The Orbit Plane remains the foundation of the entire system. It provides governance, provisioning, configuration, and monitoring—allowing ephemeral clusters to be spun up or torn down with minimal friction while ensuring operational integrity and standards remain intact.
1. Overview of the Two-Plane Architecture
In the k8or Orbit ecosystem, there are two major conceptual “planes” that together form the full architecture:
Cluster Plane:
Consists of ephemeral Kubernetes clusters.
These clusters are spun up, scaled, or torn down as needed—like short-lived environments for testing, staging, or dynamic workloads.
Their lifecycle is managed via Orbit Plane or externally, meaning they can appear or disappear without impacting the overall management or orchestration logic.
Orbit Plane:
A static, always-on environment that provides centralized management, orchestration, and control over all clusters and services.
Built from the ground up, it hosts the key components that create, monitor, update, and retire the clusters in the Cluster Plane as well as providing external access to APIs, UMBs and other services as required by applications running in the cluster.
Remains operational and persistent regardless of how many clusters in the Cluster Plane are running at any given time.
2. Cluster Plane at High-Level
Since the Cluster Plane is the simpler of the two, we’ll touch on it briefly:
Ephemeral K8s Clusters
Each cluster is a self-contained Kubernetes environment.
Clusters are labeled for specific purposes (e.g., “Dev”, “Test”, “Staging”, “Production”), or they could be created on-demand for feature testing or sandboxing.
These clusters “come and go” based on usage, capacity needs, or lifecycle events.
Workloads
Containers, microservices, or applications run inside these clusters.
When a cluster is no longer needed, it is decommissioned—the Orbit Plane coordinates its teardown to free up resources.
Key Point
The Cluster Plane is dynamic, focusing on the actual runtime environment for applications. It does not contain the permanent, overarching management systems.
3. Orbit Plane in Detailed
The Orbit Plane is the beating heart of the architecture. It remains static and underpins all operations, from provisioning new clusters to managing user access.
3.1 Purpose and Role
Central Control & Orchestration
The Orbit Plane is the command center for the entire ecosystem. It decides when to create, how to configure, and when to retire the ephemeral K8s clusters in the Cluster Plane based on User actions or Configurations.
It also coordinates updates and maintenance across clusters (e.g., rolling out new configurations, patching, or scaling).
Persistent Services & Data
While the Cluster Plane might vanish or reappear, the Orbit Plane hosts all long-lived services such as user management, identity and access control, databases, CI/CD pipelines, artifact repositories, or monitoring dashboards.
Any critical data—like user accounts, audit logs, or configuration states—lives here.
Infrastructure as Code & Automation
The Orbit Plane includes infrastructure-as-code (IaC) pipelines and automation frameworks (e.g., custom code/scripts).
This is how it can spin up or tear down entire clusters on demand while preserving repeatable, reliable processes.
3.2 Major Components
Although the specific services in the Orbit Plane may vary, here are common categories that typically appear:
OpsBoard / Management UI
A web-based interface (OpsBoard) that lets administrators and developers interact with the system.
Through this UI, users can trigger cluster creation, manage workloads, view logs, or set up environment configurations.
Components for Coordination (Kaptainor, ArgoCD, K8rix)
Orchestrators / Controllers: Components responsible for talking to the underlying infrastructure to provision new K8s clusters.
Schedulers (SyncMaster): Logic that decides which cluster to schedule new workloads on, or whether to create a fresh cluster for certain workloads.
Event Handlers (GitLab, ArgoCD, SyncMaster) : Components that listen for events (like a user request or an automated trigger) and then fire off tasks such as scaling or shutting down a cluster.
CI/CD Pipelines
Continuous Integration and Deployment tools reside in the Orbit Plane to ensure code changes are tested, built, and deployed consistently.
These pipelines can automatically push updates into any ephemeral cluster once it’s provisioned.
Artifact / Image Repositories
A Docker registry, GitHub, an S3-like storage service (ImageHarbor), and other artifact management components(ChartStore).
Ensures that application images, Helm charts, and other deployment artifacts are securely stored and versioned.
Monitoring & Logging
Central logging and monitoring solutions (e.g., Prometheus, Grafana) run in the Orbit Plane.
These systems aggregate metrics and logs from all ephemeral clusters to maintain a global view of performance and health.
Identity & Access Management
The Orbit Plane is integrated with a custom an IAM solution.
Users authenticate here, and roles/permissions are enforced across both the Orbit Plane itself and the ephemeral clusters.
Databases & Persistent Storage
Chat Store ( NoSQL) and ViewPort (Relational) databases storing user info, system configs, or operational data.
Because ephemeral clusters can vanish, we need a stable location for persistent data—and that’s in the Orbit Plane.
3.3 Lifecycle of a Cluster From Orbit Plane Perspective
Here’s a simplified flow showing how the Orbit Plane orchestrates the lifecycle of a Cluster Plane instance:
Provisioning With Orbit Components
An administrator or an automated rule triggers the creation of a new cluster K3s cluster on a bare-metal or VM on-prem or at a CP.
The Orbit Plane’s provisioning Component and Infrastructure as Code pipeline calls the necessary APIs or custom scripts/code to stand up a new K3s cluster.
Configuration & Bootstrapping with ArgoCD
Once the cluster is up, the Orbit Plane automatically applies base configurations via a ArgoCD pipeline (e.g., networking, security policies, service mesh, or standard Helm charts).
It might also register the cluster with monitoring and logging systems in the Orbit Plane.
Operation & Updates with Kaptainor & K8rix
The cluster runs workloads. The Orbit Plane keeps track of the cluster’s status, collecting logs and metrics.
If updates are needed (e.g., a new version of K3s, patching an OS), the Orbit Plane schedules these updates using various Components built into it.
Scale or Shutdown with Orbit Components
Based on usage or scheduling policies, the Orbit Plane may decide to scale the cluster up/down or terminate it altogether.
When shutting down, the Orbit Plane ensures any ephemeral data is archived or moved, if necessary, before decommissioning the cluster.
3.4 Benefits of Having an Orbit Plane
Centralized Control: Simplifies the management of multiple clusters, ensuring consistent governance, security, and policy enforcement.
Reusable Patterns: Each cluster is created from a known template or blueprint, making environment setup repeatable and less error-prone.
Scalability & Flexibility: Operators can spin up clusters on demand for new projects or tests, without manual overhead.
Reduced Risk: Ephemeral clusters are isolated and can be destroyed easily if something goes wrong, while the Orbit Plane remains untouched and stable.
4. Understanding the Orbit Plane
When understanding the Orbit Plane, remember the following points:
Static vs. Ephemeral:
The Orbit Plane is the permanent home for all “control tower” functions.
Contrast it with the ephemeral nature of the Cluster Plane.
Key Services:
Orbit Plane is made up of important in-house custom built/modified/enhenced Components.
Automation & Efficiency:
The Orbit Plane’s automation pipelines reduce manual effort and ensure consistency across all ephemeral clusters.
Governance & Security:
The Orbit Plane enforces enterprise-wide standards, from identity management to logging and compliance checks.
Observability & Insights:
Logs, metrics, and alerts flow from ephemeral clusters into the Orbit Plane for unified dashboards and real-time monitoring.
Last updated