Why this course and who it is for

This course introduces OpenShift from the ground up, aimed at people who are:

• New to containers, Kubernetes, and OpenShift
• Application developers moving toward cloud‑native development
• System administrators or DevOps engineers beginning with container platforms
• HPC or specialized‑workload users exploring OpenShift as a platform option

You do not need prior experience with Kubernetes or OpenShift. Basic familiarity with Linux and the command line will help, but key concepts will be introduced as needed.

By the end of the course, you should:

• Understand the role of OpenShift in modern IT and cloud environments
• Be comfortable navigating an OpenShift cluster using both the web console and CLI
• Know how to build, deploy, scale, and troubleshoot containerized applications on OpenShift
• Understand how OpenShift supports CI/CD, security, observability, and platform operations
• Recognize when and how to use OpenShift for HPC and specialized workloads

What you will learn, at a glance

The course is structured to take you from fundamentals to practical, real‑world usage. Each major section focuses on a specific layer of the stack or workflow.

1. Course Overview

You will first see:

• What OpenShift is and how it relates to containers and Kubernetes
• Why OpenShift is widely used in modern cloud and on‑prem environments
• How OpenShift compares to “vanilla” Kubernetes in terms of features and experience
• Typical usage scenarios in enterprise IT, cloud‑native development, and HPC
• How the rest of the course is organized and what you should focus on

2. Containers and Cloud‑Native Fundamentals

Before touching OpenShift, you will:

• Learn what containers are and how they differ from virtual machines
• Get a basic introduction to Docker‑style images and container registries
• See what “cloud‑native applications” means in practice (stateless, 12‑factor ideas, etc.)

This ensures a minimal shared foundation so OpenShift’s design and features make sense.

3. Kubernetes Fundamentals

OpenShift is built on Kubernetes, so you will:

• Understand what Kubernetes is and why it exists
• Learn high‑level Kubernetes architecture: control plane and worker nodes
• See the main control plane and node components
• Get familiar with key Kubernetes objects (Pods, Services, Deployments, etc.)
• Understand the declarative model: “desired state” and reconciliation

You will not become a deep Kubernetes expert here; the goal is enough understanding to work productively with OpenShift.

4. OpenShift Architecture

Here you connect Kubernetes concepts to OpenShift:

• The overall architecture of an OpenShift cluster
• How the OpenShift control plane extends Kubernetes
• Node and machine roles (control plane, workers, infrastructure nodes, etc.)
• How Operators are used to manage core platform functions
• OpenShift’s networking and storage models at a conceptual level

This gives you the mental map of what runs where and what OpenShift adds on top of Kubernetes.

5. OpenShift Installation and Deployment Models

You will explore how OpenShift clusters are deployed and managed in different environments:

• Common deployment options (bare metal, virtualization, public cloud)
• Installer‑Provisioned vs User‑Provisioned Infrastructure
• Managed OpenShift offerings (e.g., OpenShift as a cloud service)
• Single‑node OpenShift for edge or small environments
• Cluster lifecycle management at a conceptual level

You don’t need to be an installer expert, but you should understand what type of cluster you’re working with.

6. Accessing and Using OpenShift

This is where you start using OpenShift directly:

• Navigating and working with the OpenShift web console
• Using the oc command‑line interface
• How authentication and authorization are handled
• How Projects and namespaces organize workloads and access
• Basic use of quotas and limits to control resource usage

You will practice common tasks both via the web console and the CLI.

7. Building and Deploying Applications

You then move into application lifecycle basics on OpenShift:

• Core deployment concepts: Pods, Deployments/DeploymentConfigs, and related objects
• How Source‑to‑Image (S2I) can build containers directly from source
• Container‑based deployments using prebuilt images
• How OpenShift manages rolling updates and rollbacks

You will deploy simple applications and update them safely.

8. Networking in OpenShift

This section focuses on how applications communicate:

• Using Services and service discovery inside the cluster
• Exposing applications via Routes and ingress‑like patterns
• Applying network policies for traffic control and isolation
• Understanding load balancing at a practical level
• Providing external access to applications

You will see how to design connectivity from internal services to external clients.

9. Storage in OpenShift

Here you learn how applications persist data:

• Core concepts of persistent storage in a containerized environment
• How Persistent Volumes (PVs) and Persistent Volume Claims (PVCs) work together
• How StorageClasses and dynamic provisioning simplify storage management
• What changes when running stateful applications on OpenShift

You will practice attaching storage to applications and understand the trade‑offs involved.

10. Configuration and Secrets Management

This part covers runtime configuration of your applications:

• Storing configuration in ConfigMaps
• Managing credentials and secrets safely with Secrets
• Injecting configuration via environment variables and mounted files
• Principles and patterns for handling sensitive data
• Best practices for separating code from configuration

You will model application configuration in a way that supports multiple environments.

11. Scaling and High Availability

You then explore reliability and performance:

• Horizontal Pod Autoscaling: scaling out/in automatically
• Vertical scaling basics: adjusting resource requests/limits
• Self‑healing concepts: restarts, rescheduling, and resilience
• High availability concepts at the application and cluster levels
• Multi‑zone and multi‑region deployment patterns at a conceptual level

You will see how OpenShift helps keep applications responsive and available.

12. Monitoring, Logging, and Observability

This section shows how to understand what your cluster and apps are doing:

• What the built‑in monitoring stack provides
• Working with metrics and setting up alerts
• OpenShift’s logging architecture and common usage patterns
• Where distributed tracing fits in observability
• A structured approach to troubleshooting applications on OpenShift

You will use these tools in later hands‑on exercises to debug real scenarios.

13. Security in OpenShift

Here you learn the security model that underpins OpenShift:

• Overall security concepts relevant to OpenShift
• Role‑Based Access Control (RBAC) as applied in the platform
• Security Context Constraints (SCCs) and their impact on workloads
• Image security, scanning, and related best practices
• Network security and isolation
• Compliance and auditing considerations

You will see how security is integrated into everyday workflows, not an afterthought.

14. CI/CD and DevOps with OpenShift

You then move into delivery pipelines and DevOps practices:

• Core DevOps and CI/CD concepts as they apply to containers
• How pipelines orchestrate build, test, and deployment steps
• OpenShift Pipelines (Tekton) basics
• GitOps workflows with Argo CD
• Integrating OpenShift with external CI tools you may already use

You will build at least one simple pipeline by the end of the course.

15. Operators and Platform Services

This section introduces a key OpenShift pattern for automation:

• What Operators are and why they matter
• Using the Operator Lifecycle Manager (OLM)
• Installing and managing Operators from catalogs
• Examples of common platform Operators
• The idea of custom Operators for specialized automation

You will learn how Operators encapsulate operational knowledge into reusable components.

16. Upgrades, Maintenance, and Operations

Here the focus is on ongoing cluster care:

• How the OpenShift upgrade process works conceptually
• Approaches to backup and restore at the platform and app levels
• Typical node maintenance workflows
• Common cluster troubleshooting patterns
• Basics of capacity planning for OpenShift environments

You will not become a full‑time SRE, but you’ll understand what responsible operations look like.

17. OpenShift on HPC and Specialized Workloads

You will see how OpenShift supports non‑traditional workloads:

• Running batch workloads efficiently on OpenShift
• Using GPUs in OpenShift for compute‑intensive tasks
• Running MPI and other parallel workloads in containers
• Designing hybrid HPC and cloud workflows with OpenShift as a unifying layer

This is especially relevant if you work with scientific computing, AI/ML, or large‑scale simulations.

18. OpenShift in Practice

This part connects theory to real‑world use:

• Typical day‑to‑day workflows on OpenShift
• How code moves from development to production
• Real‑world case studies from industry and research
• Common pitfalls and practical best practices

You will analyze how different organizations structure their teams and processes around OpenShift.

19. Future Directions and Ecosystem

Here you look at the broader landscape:

• The wider Kubernetes ecosystem and how OpenShift fits within it
• OpenShift roadmap themes and evolving features
• Serverless and event‑driven workloads on OpenShift
• AI and data platforms built on top of OpenShift

This will help you understand which directions to explore after the course.

20. Final Project and Hands‑On Exercises

The course culminates with integrated practical work:

• Deploying a containerized application end‑to‑end on OpenShift
• Implementing a basic CI/CD pipeline for that application
• Applying security and scaling features appropriately
• Producing a brief monitoring and troubleshooting report

These exercises ensure you can translate concepts into working deployments.

How to use this course

To get the most from the material:

• Follow the sequence: Concepts build on one another, especially Kubernetes and OpenShift architecture.
• Practice as you go: Use the web console and oc CLI for every section when possible.
• Treat labs as essential, not optional: Hands‑on work cements understanding.
• Relate sections to your context: When you reach topics like CI/CD, security, or HPC, think about your own environment and constraints.
• Use later chapters for depth: If you are especially interested in security, Operators, or HPC, the dedicated sections allow focused deep dives without overloading earlier modules.

By the end of the course, you should be able to approach an OpenShift cluster with confidence, understand its moving parts, and deploy and operate practical applications—whether for web services, data processing, or high‑performance workloads.

Views: 322