KAHIBARO Bookshelves
Discord Login Register

1.1. What is OpenShift

OpenShift in One Sentence

OpenShift is a Kubernetes-based container platform that provides an integrated, opinionated environment for building, deploying, and running applications in a consistent way across on‑premises and cloud infrastructure.

Core Idea: A Platform, Not Just a Cluster

OpenShift is often described as a “Kubernetes platform” or “enterprise Kubernetes”. That means:

  • It includes Kubernetes, but adds:
    • Built‑in tools for developers (builds, web console, CI/CD integrations)
    • Built‑in tools for operators (cluster install, upgrade, monitoring, logging)
    • Security, governance, and multi‑tenancy features enabled by default
    • Opinionated defaults that reduce the number of decisions you need to make

You can think of it as:

  • Kubernetes = engine
  • OpenShift = complete car (engine + body + dashboard + controls + safety features)

Key Characteristics of OpenShift

Kubernetes at Its Core

  • Uses Kubernetes APIs and concepts (Pods, Services, Deployments, etc.).
  • Adds OpenShift‑specific resources and behaviors on top.
  • Compatible with most cloud‑native tooling that talks to Kubernetes.

You do not need to be a Kubernetes expert to start with OpenShift, but understanding that OpenShift builds on Kubernetes helps explain many of its behaviors and advantages.

Opinionated and Integrated

OpenShift aims to be a “batteries included” platform:

  • Provides default components for:
    • Ingress and routing
    • Container image registry
    • Monitoring and alerting
    • Logging
    • Identity and access control
  • Integrates these components so they work together out of the box, with less manual assembly.

This opinionated approach:

  • Reduces integration work for teams.
  • Encourages consistent patterns for deployment and operations.
  • Helps new users get productive faster, compared to stitching together many separate tools.

Enterprise-Grade and Production-Focused

OpenShift is designed for long‑running, production environments:

  • Supports high availability at cluster and application level.
  • Provides controlled upgrade and lifecycle management.
  • Integrates role-based access control, security policies, and multi‑tenant isolation.
  • Offers commercial support and tested combinations of components.

For organizations, this means OpenShift can serve as a standardized platform shared by many teams and applications.

Main Components at a High Level

Without going into deep architectural detail, OpenShift as a platform typically includes:

  • A Kubernetes control plane and worker nodes where your containers run.
  • A web console for visual management and development workflows.
  • A CLI tool (oc) to interact with the cluster from a terminal.
  • A built‑in container registry to store and pull application images.
  • Networking capabilities to connect applications and expose them outside the cluster.
  • Storage integration to provide persistent data volumes to applications.
  • Operators that automate the management of platform services and applications.

Each of these areas will be explored in later chapters.

Who Uses OpenShift and For What

OpenShift is used by:

  • Developers to:
    • Build, deploy, and iterate on applications quickly.
    • Use tools like Source‑to‑Image (S2I) or pipelines without managing the underlying infrastructure.
  • Platform and operations teams to:
    • Provide a shared application platform to many teams.
    • Standardize deployment, scaling, monitoring, and security policies.
  • Organizations to:
    • Run microservices, APIs, web applications, data platforms, and batch workloads.
    • Modernize legacy applications into cloud‑native architectures.
    • Run consistent environments across on‑premises data centers and public clouds.

OpenShift as a Cloud-Native Application Platform

At its core, OpenShift is about running containerized, cloud‑native applications in a reliable, repeatable way:

  • It uses containers as the unit of packaging and deployment.
  • It orchestrates these containers with Kubernetes.
  • It wraps this with processes and tools that support continuous delivery, scaling, resilience, and security.

Rather than only giving you raw cluster primitives, OpenShift presents itself as a platform that covers the typical lifecycle of an application:

  1. Build (turn code into container images)
  2. Deploy (run those images as applications)
  3. Operate (scale, monitor, secure, and upgrade them)

Variants of OpenShift

OpenShift is available in several forms, all based on the same core platform:

  • Self‑managed OpenShift:
    • Installed and operated by your own team on your chosen infrastructure (physical, virtual, or cloud).
  • Managed OpenShift services (by cloud providers or Red Hat):
    • The control plane and much of the platform are run for you.
    • You focus more on applications than on cluster operations.

These deployment models let organizations choose how much they want to own and operate versus consume as a service, without changing the core platform concepts.

How OpenShift Fits into the Bigger Picture

Within a modern IT environment, OpenShift typically sits:

  • Above infrastructure (bare metal, VMs, or cloud IaaS).
  • Below applications and developer workflows (CI/CD, GitOps, development tools).
  • Alongside other cloud‑native ecosystem tools (logging, monitoring, service mesh, etc.).

It acts as the common foundation that:

  • Provides a consistent runtime across diverse infrastructure.
  • Offers standard APIs and workflows for teams building and running software.
  • Serves as a central platform around which additional services (data, AI/ML, HPC, serverless) can be built.

This course will explore each of these aspects in more detail, but for now you can remember:

OpenShift = a Kubernetes-based, integrated, opinionated platform for building and running containerized applications in production.

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