KAHIBARO Bookshelves
Discord Login Register

1.3. OpenShift vs Kubernetes

Big Picture: How OpenShift Relates to Kubernetes

OpenShift is a Kubernetes platform, not a competitor to Kubernetes.

  • Kubernetes is the upstream, open-source container orchestration project.
  • OpenShift is a productized, opinionated, enterprise distribution of Kubernetes with additional components, defaults, and tooling.

You can think of it like this:

  • Kubernetes = kernel + core OS utilities
  • OpenShift = “full Linux distribution” built around that kernel, plus management tools, security hardening, and a support model.

So OpenShift includes Kubernetes and adds:

  • A specific, tested Kubernetes version
  • A default networking, storage, and security stack
  • Built‑in tools for builds, CI/CD, image management, and more
  • A web console and CLI tailored to the platform
  • Enterprise support and lifecycle guarantees

Upstream vs Distribution

Kubernetes: The Upstream Project

Kubernetes is:

  • A community-driven project hosted by the CNCF.
  • Released on a fast cadence (roughly every few months).
  • Packaged and shipped by many vendors as different Kubernetes distributions.

On its own, Kubernetes provides:

  • APIs and controllers to manage pods, services, etc.
  • A reference model, not a single “official” packaged product.

To build a usable platform from raw Kubernetes, an operator must decide:

  • Which CNI plugin to use
  • How to implement ingress, logging, monitoring, registry, authentication
  • How to handle upgrades, backups, multi-tenancy, quotas, and more

OpenShift: A Kubernetes Distribution

OpenShift is:

  • A Red Hat–maintained Kubernetes distribution.
  • Based on a specific Kubernetes version, with:
    • Integrated components (networking, registry, logging, monitoring, Operators)
    • Tighter defaults and policies (especially around security and multi-tenancy)
    • An opinionated installation, upgrade, and lifecycle story

OpenShift tracks upstream Kubernetes closely, but:

  • Features are brought in once they are evaluated, integrated, and tested.
  • Some components or APIs might be:
    • Marked as Technology Preview before full support
    • Hidden or disabled until they meet support criteria

Platform Scope: Bare Kubernetes vs OpenShift

What You Get with “Just Kubernetes”

With upstream Kubernetes (e.g., from kubeadm or a minimal distribution), you often need to assemble:

  • Networking (CNI: Calico, Flannel, Cilium, etc.)
  • Ingress (NGINX ingress controller, HAProxy, or similar)
  • Container registry (Harbor, Docker Registry, or cloud vendor)
  • Monitoring and logging (Prometheus, Grafana, EFK/ELK, Loki, etc.)
  • Authentication/authorization integration
  • Upgrade and cluster lifecycle tooling

The result can be very flexible but requires:

  • More design work and integration effort
  • Continuous maintenance by a platform or SRE team

What OpenShift Adds on Top

OpenShift ships as a more complete platform:

  • Distribution choice made for you:
    • Built-in SDN networking and routing layer
    • Default ingress / edge routing with Routes
  • Integrated registry for container images
  • Built-in monitoring and logging stack (platform-level)
  • Operator framework to manage platform and add-ons
  • Cluster lifecycle management (install, upgrade, day‑2 ops)
  • Web console tailored to developers and operators
  • Source-to-Image and other build/deploy workflows

The trade-off:

  • Less time spent “building a platform”
  • More time spent using the platform, but within certain conventions and guardrails

Security and Multi-Tenancy Differences

Default Security Posture

Vanilla Kubernetes:

  • Is relatively permissive by default; many distributions let containers:
    • Run as root
    • Use broader capabilities
  • Leaves security policies and enforcement largely to the cluster operator.

OpenShift:

  • Is secure by default:
    • Enforces stricter Security Context Constraints (SCCs)
    • Uses randomized, non-root UIDs by default for application containers
  • Often requires:
    • Container images to be non-root compatible
    • Proper use of file permissions and security contexts

Impact for users:

  • Some images that “just work” on a relaxed Kubernetes cluster may fail on OpenShift until they’re hardened.
  • In exchange, you get:
    • Better multi-tenant isolation
    • Reduced risk from privileged containers or misconfigured workloads

Multi-Tenancy and Quotas

Kubernetes supports:

  • Namespaces, Role-Based Access Control (RBAC), and ResourceQuota.
  • But design and enforcement of multi-tenant models is largely left to you.

OpenShift builds multi-tenancy into:

  • Projects (namespaces plus additional metadata and policies)
  • Quota and limit-range integration as a normal part of project setup
  • Predefined cluster roles and bindings aimed at:
    • Cluster admins
    • Project admins
    • Developers

The result is a more opinionated multi-tenant experience, designed for many teams sharing a single cluster.

Developer Experience: Kubernetes vs OpenShift

APIs Are Mostly the Same

At the core:

  • Pods, Deployments, Services, ConfigMaps, Secrets, etc. are Kubernetes-native on OpenShift.
  • YAML manifests for these resources are usually:
    • Portable between Kubernetes and OpenShift, with minor differences in:
      • SecurityContext
      • Ingress vs Route configuration
      • Storage classes and annotations

OpenShift adds its own resources (e.g., Routes, some Operator CRDs), but they are built on top of Kubernetes APIs.

Tooling: kubectl vs oc

  • Kubernetes uses kubectl as the standard CLI.
  • OpenShift uses oc:
    • oc can run most kubectl-like commands (oc get pods, etc.).
    • It also includes OpenShift-specific commands, for example:
      • oc new-app to quickly create applications from images or source
      • Project and user-focused commands that understand OpenShift’s model

In practice:

  • OpenShift users interact with both standard Kubernetes APIs and OpenShift-specific enhancements.

Web Console vs Raw Kubernetes UI

Kubernetes itself only provides a basic dashboard in some distributions, and it is often:

  • Optional
  • Not enabled by default
  • Not heavily integrated with auth/audit in many setups

OpenShift provides a full web console that:

  • Exposes Kubernetes objects and OpenShift-specific resources
  • Offers:
    • Developer views (applications, topology, pipelines)
    • Administrator views (nodes, Operators, cluster settings)
  • Is tightly integrated with cluster authentication and RBAC

From a user perspective, OpenShift feels more like a managed platform, not just a cluster API.

Application Exposure: Ingress vs Routes

Both platforms can expose applications externally, but the abstractions differ.

Kubernetes:

  • Uses Ingress resources (and Ingress controllers) to:
    • Map hostnames and paths to Services
  • Details of behavior depend on the Ingress controller implementation.

OpenShift:

  • Supports Ingress, but also introduces Routes:
    • A Route is an OpenShift-specific resource that:
      • Exposes a Service externally
      • Encapsulates hostnames, TLS termination, and routing policies
  • Provides a built-in routing layer:
    • Typically an HAProxy-based router managed by the platform

Implications:

  • On a plain Kubernetes cluster, teams may choose among many Ingress controllers.
  • On OpenShift, you get a standard, integrated approach through Routes (with Ingress available as well).

Integrated Platform Services and Operators

Operators and Extensibility

Kubernetes supports:

  • Custom Resource Definitions (CRDs) and controllers, which form the basis of the Operator pattern.
  • Many Operators are installed manually or via third-party catalogs.

OpenShift:

  • Includes the Operator Lifecycle Manager (OLM).
  • Provides a curated OperatorHub with:
    • Platform Operators (for OpenShift itself)
    • Add-on Operators (databases, messaging, storage, etc.)
  • Uses Operators extensively to manage:
    • Core platform components
    • Upgrades and configuration of cluster services

This means:

  • Adding a complex service (e.g., a database cluster) often becomes:
    • Install Operator
    • Create a Custom Resource
    • Let the Operator manage lifecycle

Whereas on bare Kubernetes:

  • You might need to deploy and maintain Helm charts or manifests yourself, with less integrated lifecycle management.

Installation, Upgrades, and Lifecycle

Kubernetes: Many Ways to Install

For Kubernetes, there are multiple distributions and installers:

  • kubeadm, kops, cluster API providers, cloud-vendor managed Kubernetes (EKS, GKE, AKS), etc.
  • Lifecycle (upgrades, node replacement, etc.) is often:
    • Distribution- or vendor-specific
    • Managed by your DevOps / platform team or cloud provider

OpenShift: Opinionated Lifecycle Management

OpenShift provides:

  • A defined set of deployment models:
    • Installer-Provisioned vs User-Provisioned Infrastructure
    • Managed OpenShift offerings
    • Single-node variants
  • A cluster version operator to:
    • Orchestrate platform upgrades
    • Coordinate Operator and component versions
  • A supported and documented upgrade path:
    • Tested version combinations
    • Backward compatibility guarantees within support windows

For organizations, this means:

  • A predictable lifecycle with clear support boundaries
  • Less need to design and maintain custom upgrade orchestration

Licensing, Support, and Ecosystem Position

Open Source vs Subscription

Kubernetes:

  • Is entirely open source, with no licensing fees.
  • Support is:
    • Community-based, or
    • Provided by a vendor that repackages Kubernetes

OpenShift:

  • Is based on open source components (including Kubernetes), but:
    • Distributed under Red Hat’s subscription model
    • Comes with commercial support, SLAs, and lifecycle guarantees

Cost vs benefit:

  • Kubernetes alone:
    • Lower direct software cost
    • Higher internal engineering and operations cost
  • OpenShift:
    • Licensing/subscription cost
    • Lower internal cost for building and maintaining the base platform, plus vendor accountability

Ecosystem and Integration

Both Kubernetes and OpenShift:

  • Leverage the broader cloud-native ecosystem:
    • CNCF projects
    • Container runtimes
    • Storage and network plugins

OpenShift focuses on:

  • Curated integrations:
    • Tested combinations of CNIs, storage backends, Operators
    • Certified partner solutions
  • Close integration with:
    • Red Hat Enterprise Linux / CoreOS
    • Red Hat’s broader portfolio (e.g., Ansible, RHEL, Quay, etc.)

This makes OpenShift particularly attractive where:

  • Enterprise-grade support, certifications, and compliance matter.
  • Teams want a single throat to choke for the platform stack.

When to Use Kubernetes Alone vs OpenShift

Situations Suited to “Raw” Kubernetes or Minimal Distributions

  • You need maximum flexibility in choosing every component.
  • You have a strong SRE / platform engineering team.
  • Cost sensitivity outweighs the value of a commercial platform.
  • You’re building a highly custom platform (e.g., specialized research clusters).

Situations Suited to OpenShift

  • You want a ready-to-use enterprise Kubernetes platform.
  • Security, multi-tenancy, and compliance are high priorities.
  • You prefer a single vendor for platform support and lifecycle.
  • You want batteries-included tooling:
    • Web console
    • Integrated registry
    • Built-in monitoring/logging
    • Operator-driven services
  • You are standardizing across:
    • On-premises, private, and public clouds with a consistent environment.

In practice, many organizations end up with:

  • Multiple Kubernetes environments, some of which are OpenShift clusters.
  • OpenShift used as the primary enterprise platform, with other Kubernetes distributions used for special cases or in clouds where a managed service is already in place.

Summary of Key Differences

Conceptually:

  • Kubernetes = core orchestration engine and APIs
  • OpenShift = opinionated, integrated Kubernetes platform with enterprise support

Key contrasts:

  • Project vs product: Kubernetes is upstream; OpenShift is a distribution.
  • Flexibility vs integration: Kubernetes is highly flexible; OpenShift is more integrated and opinionated.
  • Security defaults: OpenShift is stricter and more secure by default.
  • Developer and operator experience: OpenShift adds a rich web console, oc CLI enhancements, Routes, and platform services.
  • Lifecycle and support: OpenShift provides defined upgrade paths and vendor support; raw Kubernetes depends on your chosen vendor or your own team.

Understanding this relationship is essential for deciding where OpenShift fits in an organization’s overall Kubernetes and cloud-native strategy.

Views: 0

Comments

Please login to add a comment.

Don't have an account? Register now!

Where to Move

Move chapter:

  • ☰ 1. Course Overview
    • ☰ 1.1. What is OpenShift
      • ☰ 1.2. Why OpenShift is used in modern IT and cloud environments
        • ☰ 1.3. OpenShift vs Kubernetes
          • ☰ 1.4. Typical OpenShift use cases
            • ☰ 1.5. Structure and goals of the course
            • ☰ 2. Containers and Cloud-Native Fundamentals
              • ☰ 2.1. What is a container
                • ☰ 2.2. Containers vs virtual machines
                  • ☰ 2.3. Introduction to Docker and container images
                    • ☰ 2.4. Container registries
                      • ☰ 2.5. Basics of cloud-native applications
                      • ☰ 3. Kubernetes Fundamentals
                        • ☰ 3.1. What is Kubernetes
                          • ☰ 3.2. Kubernetes architecture
                            • ☰ 3.3. Control plane components
                              • ☰ 3.4. Worker node components
                                • ☰ 3.5. Kubernetes objects and resources
                                  • ☰ 3.6. Declarative configuration model
                                  • ☰ 4. OpenShift Architecture
                                    • ☰ 4.1. Overview of OpenShift architecture
                                      • ☰ 4.2. Control plane in OpenShift
                                        • ☰ 4.3. Nodes and machine roles
                                          • ☰ 4.4. OpenShift Operators
                                            • ☰ 4.5. OpenShift networking model
                                              • ☰ 4.6. OpenShift storage model
                                              • ☰ 5. OpenShift Installation and Deployment Models
                                                • ☰ 5.1. OpenShift deployment options
                                                  • ☰ 5.2. Installer-Provisioned Infrastructure
                                                    • ☰ 5.3. User-Provisioned Infrastructure
                                                      • ☰ 5.4. Managed OpenShift services
                                                        • ☰ 5.5. Single-node OpenShift
                                                          • ☰ 5.6. Cluster lifecycle management
                                                          • ☰ 6. Accessing and Using OpenShift
                                                            • ☰ 6.1. OpenShift web console
                                                              • ☰ 6.2. OpenShift CLI (oc)
                                                                • ☰ 6.3. Authentication and authorization
                                                                  • ☰ 6.4. Projects and namespaces
                                                                    • ☰ 6.5. Resource quotas and limits
                                                                    • ☰ 7. Building and Deploying Applications
                                                                      • ☰ 7.1. Application deployment concepts
                                                                        • ☰ 7.2. Source-to-Image (S2I)
                                                                          • ☰ 7.3. Container-based deployments
                                                                            • ☰ 7.4. DeploymentConfigs and Deployments
                                                                              • ☰ 7.5. Rolling updates and rollbacks
                                                                              • ☰ 8. Networking in OpenShift
                                                                                • ☰ 8.1. Services and service discovery
                                                                                  • ☰ 8.2. Routes and ingress
                                                                                    • ☰ 8.3. Network policies
                                                                                      • ☰ 8.4. Load balancing
                                                                                        • ☰ 8.5. External access to applications
                                                                                        • ☰ 9. Storage in OpenShift
                                                                                          • ☰ 9.1. Persistent storage concepts
                                                                                            • ☰ 9.2. Persistent Volumes
                                                                                              • ☰ 9.3. Persistent Volume Claims
                                                                                                • ☰ 9.4. StorageClasses
                                                                                                  • ☰ 9.5. Dynamic provisioning
                                                                                                    • ☰ 9.6. Stateful applications
                                                                                                    • ☰ 10. Configuration and Secrets Management
                                                                                                      • ☰ 10.1. ConfigMaps
                                                                                                        • ☰ 10.2. Secrets
                                                                                                          • ☰ 10.3. Environment variables
                                                                                                            • ☰ 10.4. Managing sensitive data
                                                                                                              • ☰ 10.5. Best practices for configuration
                                                                                                              • ☰ 11. Scaling and High Availability
                                                                                                                • ☰ 11.1. Horizontal pod autoscaling
                                                                                                                  • ☰ 11.2. Vertical scaling
                                                                                                                    • ☰ 11.3. Self-healing and pod restarts
                                                                                                                      • ☰ 11.4. High availability concepts
                                                                                                                        • ☰ 11.5. Multi-zone and multi-region clusters
                                                                                                                        • ☰ 12. Monitoring, Logging, and Observability
                                                                                                                          • ☰ 12.1. Built-in monitoring stack
                                                                                                                            • ☰ 12.2. Metrics and alerts
                                                                                                                              • ☰ 12.3. Logging architecture
                                                                                                                                • ☰ 12.4. Distributed tracing
                                                                                                                                  • ☰ 12.5. Troubleshooting applications
                                                                                                                                  • ☰ 13. Security in OpenShift
                                                                                                                                    • ☰ 13.1. Security model overview
                                                                                                                                      • ☰ 13.2. Role-Based Access Control
                                                                                                                                        • ☰ 13.3. Security Context Constraints
                                                                                                                                          • ☰ 13.4. Image security and scanning
                                                                                                                                            • ☰ 13.5. Network security
                                                                                                                                              • ☰ 13.6. Compliance and auditing
                                                                                                                                              • ☰ 14. CI/CD and DevOps with OpenShift
                                                                                                                                                • ☰ 14.1. DevOps concepts
                                                                                                                                                  • ☰ 14.2. CI/CD pipelines overview
                                                                                                                                                    • ☰ 14.3. OpenShift Pipelines (Tekton)
                                                                                                                                                      • ☰ 14.4. GitOps with Argo CD
                                                                                                                                                        • ☰ 14.5. Integrating OpenShift with external CI tools
                                                                                                                                                        • ☰ 15. Operators and Platform Services
                                                                                                                                                          • ☰ 15.1. What are Operators
                                                                                                                                                            • ☰ 15.2. Operator Lifecycle Manager
                                                                                                                                                              • ☰ 15.3. Installing and managing Operators
                                                                                                                                                                • ☰ 15.4. Common platform Operators
                                                                                                                                                                  • ☰ 15.5. Custom Operators
                                                                                                                                                                  • ☰ 16. Upgrades, Maintenance, and Operations
                                                                                                                                                                    • ☰ 16.1. OpenShift upgrade process
                                                                                                                                                                      • ☰ 16.2. Backup and restore
                                                                                                                                                                        • ☰ 16.3. Node maintenance
                                                                                                                                                                          • ☰ 16.4. Cluster troubleshooting
                                                                                                                                                                            • ☰ 16.5. Capacity planning
                                                                                                                                                                            • ☰ 17. OpenShift on HPC and Specialized Workloads
                                                                                                                                                                              • ☰ 17.1. Running batch workloads on OpenShift
                                                                                                                                                                                • ☰ 17.2. OpenShift and GPUs
                                                                                                                                                                                  • ☰ 17.3. MPI and parallel workloads in containers
                                                                                                                                                                                    • ☰ 17.4. Hybrid HPC and cloud workflows
                                                                                                                                                                                    • ☰ 18. OpenShift in Practice
                                                                                                                                                                                      • ☰ 18.1. Typical OpenShift workflows
                                                                                                                                                                                        • ☰ 18.2. Development to production lifecycle
                                                                                                                                                                                          • ☰ 18.3. Case studies from industry
                                                                                                                                                                                            • ☰ 18.4. Common pitfalls and best practices
                                                                                                                                                                                            • ☰ 19. Future Directions and Ecosystem
                                                                                                                                                                                              • ☰ 19.1. Kubernetes ecosystem overview
                                                                                                                                                                                                • ☰ 19.2. OpenShift roadmap
                                                                                                                                                                                                  • ☰ 19.3. Serverless and event-driven workloads
                                                                                                                                                                                                    • ☰ 19.4. AI and data platforms on OpenShift
                                                                                                                                                                                                    • ☰ 20. Final Project and Hands-On Exercises
                                                                                                                                                                                                      • ☰ 20.1. Deploying a containerized application
                                                                                                                                                                                                        • ☰ 20.2. Implementing CI/CD with OpenShift
                                                                                                                                                                                                          • ☰ 20.3. Securing and scaling an application
                                                                                                                                                                                                            • ☰ 20.4. Monitoring and troubleshooting report