Skip to main content

Kcp

Kubernetes Control Plane (KCP) is an open source control-plane platform that provides a multi-tenant, API-first abstraction layer compatible with Kubernetes-style APIs for organizing, isolating, and orchestrating workloads across multiple clusters and environments (platform orchestration / multi-cluster control plane).

  • Multi-tenant workspace model for logical cluster and Application Programming Interface (API) isolation (platform orchestration).
  • Kubernetes-style API server that hosts and aggregates APIs without requiring a backing data plane (control plane abstraction).
  • Supports organizing and scheduling workloads and services across multiple Kubernetes clusters (multi-cluster management).
  • Extensible API platform for defining, discovering, and composing APIs and resources through schemas and plug-ins (API platform).
  • Provides a foundation for building higher-level platforms, portals, and control planes on top of existing clusters and services (platform engineering).

More About Kcp

KCP is an open source control-plane platform that focuses on providing a Kubernetes-style API environment without being tied to a single Kubernetes cluster. It introduces a logical control-plane layer for organizing APIs, workloads, and configurations across many physical clusters or external systems. The project centers on a multi-tenant design, where tenants interact with KCP workspaces that behave as logical clusters, while actual compute and storage can reside in one or more underlying Kubernetes clusters or other backends.

At its core, KCP runs an API server compatible with Kubernetes-style APIs (control plane orchestration). It exposes resource types through schemas, supports Kubernetes CustomResourceDefinitions-like behavior, and enables API aggregation, so multiple APIs can coexist behind one logical endpoint. Unlike a traditional Kubernetes cluster, KCP does not mandate a local node or pod execution data plane; instead, it focuses on API governance, multi-tenancy, and orchestration of external controllers and clusters.

The workspace model (multi-tenancy / logical isolation) is a central capability of KCP. Workspaces act as logical clusters that group APIs, resources, and policies for a team, application, or environment. These workspaces can be organized hierarchically, allowing platform engineers to create structures for organizations, projects, or environments such as development, staging, and production. This model is designed to give each tenant a Kubernetes-like experience while using shared control-plane infrastructure.

KCP also targets multi-cluster scenarios (multi-cluster management). It can coordinate workloads and APIs across multiple Kubernetes clusters, using placement and scheduling concepts to Marketing Automation Platform (MAP) logical resources in KCP to physical clusters. Controllers running against KCP can propagate resources into target clusters, collect status back into KCP, and implement higher-level behaviors such as failover, sharding, or regional placement. This enables enterprises to use KCP as a control point over heterogeneous fleets of clusters deployed across data centers or clouds.

The project positions itself as an API platform (API management / platform engineering) for building higher-level products and internal platforms. Developers and platform teams can register new APIs in KCP, discover them via the central API server, and build controllers and services that operate consistently across tenants and clusters. KCP’s abstractions are designed to integrate with the Kubernetes ecosystem by reusing familiar resource patterns, client libraries, and tooling, which can reduce friction for teams adopting it as a higher-level control plane.

In enterprise and institutional environments, KCP can be used as a shared control plane that sits above existing clusters and services. It can provide common policy, tenancy, and governance constructs, while allowing each line of business or application team to work in its own workspace. Because KCP focuses on the control-plane layer, it can be integrated with existing Continuous Integration and Continuous Deployment (CI/CD) pipelines, infrastructure automation, and observability stacks, serving as the API hub through which new services and platform capabilities are exposed and managed.