Platform Comparison

OpenShift vs Standard CNCF Kubernetes on OpenStack: Architecture & TCO

A technical and financial comparison for infrastructure directors and platform leads: comparing full-stack Kubernetes distributions against standard CNCF Kubernetes running on OpenStack.

1. Architectural Paradigm: Opinionated Distribution vs Standard API

Red Hat OpenShift (and its open-source upstream project OKD) packages Kubernetes with a specialized ecosystem: Red Hat Enterprise Linux CoreOS (RHCOS), OpenShift-specific `SecurityContextConstraints` (SCCs), specialized Routes, and custom build pipelines (S2I). While this creates an integrated stack, it requires specific manifest conventions.

In contrast, running standard CNCF-conformant Kubernetes on OpenStack preserves standard upstream APIs: standard Ingress controllers (Traefik, NGINX), standard Pod Security Standards (PSS), and standard OCI container runtimes.

2. The Economics: Per-Core Licensing vs Per Managed Resource

The financial model of enterprise Kubernetes distributions is traditionally structured around per-core or per-vCPU subscription pairs. As hardware nodes scale to high core counts (64 to 128 cores per socket), the licensing cost scales with core count even if cluster utilization remains modest.

Dimension Red Hat OpenShift (OCP) Standard CNCF K8s on OpenStack
Licensing Model Per-core / 2-core subscription packs Per managed cluster / resource (core-agnostic)
Node Operating System Mandatory RHCOS on all cluster nodes Standard enterprise Linux distributions
Non-Kubernetes Workloads OpenShift Virtualization (KubeVirt overlay) Native OpenStack Nova VMs with standard flavor definitions
Upstream Alignment OKD (Community upstream) / Commercial OCP Standard upstream CNCF Kubernetes binaries

3. Day-2 Operations & OS Immutability

OpenShift clusters couple the node operating system (RHCOS) with the Kubernetes control plane. In contrast, running standard Kubernetes on OpenStack decouples the underlying Linux host image from cluster lifecycle automation, allowing rolling version updates without mandatory OS reimaging.

4. Ecosystem Portability: Helm, CRDs & GitOps Compatibility

Standard CNCF Kubernetes ensures that third-party Helm charts and open-source operators deploy without modifying security contexts or translating standard Kubernetes `Ingress` resources into OpenShift-specific `Route` definitions. Platform teams can use standard ArgoCD or Flux GitOps pipelines seamlessly.

5. Architectural Transition Strategy

Transitioning from OpenShift to standard Kubernetes involves migrating OpenShift Routes to standard Ingress manifests, moving persistent volume claims to OpenStack Cinder CSI, and deploying standard Helm releases.

For a full overview of how edgeContinuum delivers managed upstream Kubernetes on private infrastructure, explore our OpenShift alternative platform. For the component level of standard Kubernetes on OpenStack, the cloud controller manager, Cinder CSI, the CNI and the provisioning routes, see the Kubernetes on OpenStack architecture guide.

Evaluate your Kubernetes platform architecture with us

Analyze your cluster footprint, core licensing overhead, and migration path to standard CNCF Kubernetes on OpenStack.

Frequently asked questions

Is OpenShift worth the cost compared with standard Kubernetes?
It depends entirely on whether you would build what it bundles. OpenShift ships an integrated developer experience, an opinionated security posture, an operator catalog and a support relationship, and for organizations that would otherwise assemble those from parts, the per-core cost can be defensible. It stops being defensible when you are paying per core for workloads that do not need the bundle, when the estate grows denser and the bill grows with it, or when the opinionated pieces are ones you have already solved another way.
What do we lose by moving from OpenShift to standard CNCF Kubernetes?
Mostly convenience and defaults, not capability. You lose Routes, DeploymentConfigs, ImageStreams, the integrated build system and OpenShift's SCC model, and each has a standard equivalent: Ingress or Gateway API, Deployments, an external registry, an external CI system, and Pod Security Admission. You also lose the single support contract covering the whole stack. What you gain is a smaller surface with no proprietary APIs, so manifests stay portable and the licence stops scaling with your core count.
Is OKD a viable OpenShift replacement?
Technically yes, since OKD is the community distribution OpenShift is built from and behaves very similarly. The question is operational rather than technical: OKD comes without the support relationship, has a different release cadence, and leaves you owning upgrades and incident response for a fairly complex platform. Teams that choose OKD successfully tend to have real Kubernetes depth already. Teams choosing it purely to avoid the licence usually discover they replaced a cost line with a staffing line.
How does per-core pricing compare with per managed resource?
They scale on different axes, which is what makes the comparison awkward and important. Per-core pricing grows with hardware density, so consolidating workloads onto larger hosts increases the bill even though it improves utilisation. Per managed resource counts the things the platform manages, a cluster, a database, a virtual machine, so denser hardware reduces cost per workload. The crossover point arrives sooner than most teams expect, and it arrives faster still if you run large nodes for memory-heavy workloads.
Can we run OpenShift workloads on standard Kubernetes without rewriting them?
Standard container workloads move essentially unchanged, since they are just pods. The work is in the OpenShift-specific objects around them: Routes become Ingress or Gateway API resources, DeploymentConfigs become Deployments, ImageStreams become plain image references, and BuildConfigs move to your CI system. Anything relying on SCCs needs mapping to Pod Security Admission. For most applications this is a mechanical conversion plus testing rather than a rewrite, and it is usually done namespace by namespace.