KAHIBARO Bookshelves
Discord Login Register

1.5. Structure and goals of the course

How this course is organized

This course is structured to take you from “I’ve heard of OpenShift” to being able to confidently deploy, manage, and troubleshoot applications on an OpenShift cluster, with a particular eye toward real-world environments, including HPC and specialized workloads.

The progression is intentional:

  1. Big-picture orientation – Why OpenShift exists and where it fits.
  2. Foundations – Containers, Kubernetes, and cloud‑native principles.
  3. Core OpenShift skills – Architecture, installation models, access, and day‑to‑day use.
  4. Application lifecycle – Building, deploying, scaling, securing, and operating apps.
  5. Platform extensibility and operations – Operators, upgrades, maintenance.
  6. Specialized and advanced use cases – HPC, AI, GitOps, and ecosystem topics.
  7. Integration and synthesis – A final project that ties everything together.

Each top‑level section focuses on a distinct competency. You can think of them as layers that build on each other:

  • Course Overview
    Positions OpenShift in the broader cloud and Kubernetes landscape and explains why you’d choose it. This gives you context for all subsequent technical topics.
  • Containers and Cloud‑Native Fundamentals
    Ensures you understand containers, images, and cloud‑native ideas before touching Kubernetes or OpenShift specifics. This is the conceptual foundation.
  • Kubernetes Fundamentals
    Provides the baseline Kubernetes concepts you need to understand what OpenShift is extending or adding. You will not become a full Kubernetes expert here, but you will know enough to reason about OpenShift’s design.
  • OpenShift Architecture
    Maps the generic Kubernetes model to OpenShift’s specific components, roles, and patterns. This is where “OpenShift as a platform” starts to become concrete.
  • OpenShift Installation and Deployment Models
    Explains how OpenShift clusters are deployed in different environments (on‑prem, cloud, managed services, etc.), and how that affects responsibilities and workflows.
  • Accessing and Using OpenShift
    Focuses on how users and administrators actually interact with the platform (web console, CLI, auth, projects, quotas). This is about day‑to‑day usability.
  • Building and Deploying Applications
    Walks through application deployment models on OpenShift, including S2I and container‑based deployments, and how rollouts are managed.
  • Networking in OpenShift
    Covers how services, routing, and network policies work in an OpenShift cluster, and how applications become reachable internally and externally.
  • Storage in OpenShift
    Explains persistent storage concepts in the OpenShift context—how workloads get reliable data storage independent of nodes.
  • Configuration and Secrets Management
    Focuses on separating config from code, safely handling secrets, and applying best practices for application configuration.
  • Scaling and High Availability
    Deals with making workloads resilient and elastic: pod autoscaling, vertical scaling considerations, and HA patterns at cluster and app level.
  • Monitoring, Logging, and Observability
    Shows how to gain insight into running applications and the platform, and how to use those insights to troubleshoot.
  • Security in OpenShift
    Presents OpenShift’s security model and how to apply it in practice—access control, image security, network protections, and compliance‑oriented features.
  • CI/CD and DevOps with OpenShift
    Connects OpenShift to modern DevOps workflows with pipelines, GitOps, and CI integrations.
  • Operators and Platform Services
    Introduces Operators as a way to encode operational knowledge and manage complex platform services.
  • Upgrades, Maintenance, and Operations
    Focuses on keeping clusters healthy over time: upgrades, backups, node maintenance, and capacity planning.
  • OpenShift on HPC and Specialized Workloads
    Explores how OpenShift can be used for batch, GPU, MPI, and hybrid cloud/HPC scenarios.
  • OpenShift in Practice
    Grounded, experience‑driven content: typical workflows, real‑world case studies, and common mistakes.
  • Future Directions and Ecosystem
    Orients you in the broader Kubernetes/OpenShift ecosystem and where the platform is heading (e.g., serverless, AI platforms).
  • Final Project and Hands‑On Exercises
    Structured, practical work to ensure you can apply everything you’ve learned to realistic scenarios.

Learning goals

By the end of this course, you should be able to:

  1. Explain where OpenShift fits
    • Articulate how OpenShift relates to containers, Kubernetes, and cloud‑native architectures.
    • Identify when OpenShift is an appropriate platform choice (including for HPC and data‑intensive workloads).
  2. Navigate and use an OpenShift cluster effectively
    • Log in and work with the web console and oc CLI.
    • Understand projects/namespaces, resource quotas, and basic multi‑tenancy concepts.
  3. Deploy and manage containerized applications on OpenShift
    • Use OpenShift‑native workflows like S2I and image‑based deployments.
    • Configure applications with ConfigMaps, Secrets, and environment variables.
    • Expose applications via Services and Routes.
  4. Provide storage and networking for applications
    • Choose appropriate storage classes and provisioning approaches for different app types.
    • Design basic network access patterns and apply policies for isolation and security.
  5. Implement scaling, resilience, and observability
    • Configure horizontal scaling and understand when vertical scaling is appropriate.
    • Interpret metrics, logs, and alerts for troubleshooting.
    • Apply high‑level HA concepts in cluster and workload design.
  6. Apply security and access control practices
    • Use RBAC and Security Context Constraints to control what workloads and users can do.
    • Integrate image security and network security considerations into your deployments.
  7. Integrate OpenShift into DevOps workflows
    • Describe and use basic CI/CD and GitOps patterns on OpenShift.
    • Understand where platform Operators and pipelines fit into a modern delivery toolchain.
  8. Operate and evolve OpenShift environments
    • Understand upgrade paths and cluster lifecycle management responsibilities.
    • Apply backup/restore concepts and basic capacity planning.
    • Recognize when and how to use Operators to manage platform services.
  9. Apply OpenShift to specialized workloads
    • Understand at a conceptual level how to run GPU‑accelerated and MPI/parallel workloads in containers on OpenShift.
    • Reason about hybrid HPC‑cloud workflows and what OpenShift can contribute.
  10. Deliver an end‑to‑end solution
    • Take an application from source code to a running, observable, and secure deployment on OpenShift.
    • Document and justify architectural and operational decisions in the context of what you learned.

How to use this course

  • Follow the sequence
    The material is cumulative. Later sections assume familiarity with earlier ones, especially from the fundamentals and architecture chapters.
  • Alternate theory with practice
    Concepts are reinforced with hands‑on tasks and the final project. Aim to try out commands, manifests, and workflows as soon as you encounter them.
  • Use the outline as a reference map
    Once you’ve gone through the course once, you can come back to individual chapters as a reference for specific areas (e.g., “Networking in OpenShift” when debugging routing issues).
  • Keep your own “cluster notebook”
    As you progress, note down:
    • Typical commands you use (oc invocations, YAML snippets).
    • Common patterns that work well in your environment.
    • Issues you encounter and how you solved them.
      This will help when you build your final project and in real‑world usage.

Prerequisites and expectations

This course is intentionally designed for learners who may be:

  • New to containers and Kubernetes.
  • New to OpenShift specifically.
  • Coming from traditional IT, HPC, or development backgrounds.

You are expected to:

  • Be comfortable with basic command‑line usage (shell, basic file operations).
  • Have a general understanding of what an application and a server are, even if you’ve never worked with containers.

Everything else—containers, Kubernetes context, OpenShift concepts, CI/CD, security, observability, and HPC‑related usage—will be introduced within the course in a structured way, at the right depth for beginners.

Assessment and outcomes

Your progress will be assessed primarily through:

  • Hands‑on exercises embedded in technical sections.
  • A final project where you:
    • Deploy a containerized application to OpenShift.
    • Implement a basic CI/CD or GitOps‑style workflow.
    • Apply security, scaling, and observability features.
    • Produce a short report explaining your design and troubleshooting steps.

Successfully completing the course means you should be ready to:

  • Participate in OpenShift‑based projects as a developer, operator, or power user.
  • Understand discussions about platform design and trade‑offs.
  • Continue self‑learning in more specialized areas (e.g., advanced Operators, deep HPC integration, AI platforms) using the solid base you’ve gained here.

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