OpenShift for the Absolute Beginners

Explore how containers and orchestration work, with a focus on Docker containers, images, and runs, and understand how Kubernetes enables scalable, portable applications across environments.

Explore Kubernetes as a container orchestration platform that automatically scales containers based on load. Use declarative object configuration files for scalable, highly available deployments with load balancing across multiple containers.

Sign up for a free Red Hat account to access OpenShift installation methods, register on redhat.com, create your username and password, and begin the course.

Learn to install and start a single-node OpenShift locally with CodeReady Containers (CRC) on Windows, including prerequisites, Hyper-V setup, and logging in as kubeadmin.

Demonstrates installing a single OpenShift node using the sandbox in the cloud, not locally. Highlights sandbox access, security prompts, 30-day expiry, and that it's free and not for production.

Explore how to install a production-ready OpenShift cluster across cloud services, including Azure Red Hat OpenShift, with authentication, networking, and quotas.

Explore OpenShift's UI and CLI, comparing developer and administrator portals, and preview deployments, services, and config maps while learning yaml manifests and basic workflows.

Learn to deploy applications in OpenShift using the web console, including creating deployments from Kubernetes manifests or importing a git repo with a Docker-based app, routes, and pods.

Deploy applications on OpenShift using the oc CLI, applying YAML manifests to set up deployments, services, and databases for the Sock Shop demo.

Discover how openshift projects isolate resources, organize teams, and simplify access with namespaces, while understanding regular, system, and service accounts and oauth-based authentication and authorization.

Explore OpenShift projects and users via the CLI and UI, create new projects, and grant cluster administrator access to a new user using oc adm policy add-cluster-roll-to-user.

OpenShift provides a user-friendly platform on top of Kubernetes, using a console and CLI to manage users, projects, builds, and deployments, while Kubernetes handles pods behind the scenes.

Compare Kubernetes deployments and OpenShift deployment configs, explain replica set versus replica controller, set-based versus equality-based selectors, and swapping container images, with a recommendation to use deployments.

Shows how to deploy cartodb in OpenShift with both a standard deployment and a deployment config, configure a MongoDB-backed service, and monitor pods, replicas, and events via UI and CLI.

Learn how image streams in OpenShift automatically roll out new container image versions through tags, trigger deployments, and keep builds in a repeatable, automated flow by watching registries.

Create and deploy an image stream for a Sock Shop cart app using OpenShift, and use the OC new app command with a specific image stream while handling deployment conflicts.

OpenShift for the absolute beginners shows how a build turns source code into a container image, and how a build config enables that automatic creation, often via a build strategy.

Demonstrates creating a build config in OpenShift to build the sock shop app from a GitHub repo, configure git source and image stream tag, and trigger builds.

A route exposes a service inside OpenShift to a hostname, routing a URL to an application. Kubernetes perspective likens this to a load balancer fronting service via IP or DNS.

Delete the existing route, then create a route named front end app with an auto-generated hostname, choose the front end service and port, and enable a secure route with certs.

Explore OpenShift build strategies—source to image, pipeline, docker, and custom—using git sources, Docker files, binaries, and image sources, with secrets and artifacts, to create container images.

OpenShift's builder creates OCI-compliant container images from a Dockerfile, automating builds from a git source and producing an image like go web API latest in the OpenShift container registry.

Discover how S2I converts source code into Docker compliant container images, automating builds, avoiding dockerfiles, pushes to a Docker registry, and enabling secure, incremental, reuse-friendly deployments on OpenShift.

Discover how OpenShift's custom image builder bridges container images and artifact creation, enabling build process logic, CI/CD, and secure deployment from a git repo to a tagged image.

Learn how to automate OpenShift builds with webhooks, image change, and configuration change triggers, moving from manual builds to repeatable pipelines and gitops-inspired workflows.

Explore OpenShift networking basics, including an overlay network using Open vSwitch, unique pod IPs, DNS mapping with SkyDNS, and the role of services for external access.

Explore how openshift services connect apps and pods with IP addresses, acting as load balancers. Learn how routes expose services to users, configure SSL, redirects, and traffic splitting.

Expose an OpenShift app by creating a service linked to pods on port 8080 with a service-config.yml, then create a route for external access and test with curl.

Learn how to scale an OpenShift deployment by adjusting the replication controller replicas, either in yaml or via the web console, with traffic distributed by a service or router.

Watch a beginner OpenShift demo that deploys a simple web app, scales replicas, and configures route load balancing with roundrobin and cookies disabled.

Learn horizontal pod autoscaling (hpa) in OpenShift by adjusting replica counts based on CPU and memory load, and understand when to scale up or down.

Explore horizontal pod autoscaling in OpenShift via the oc auto scale command and a Kubernetes horizontal pod autoscaler YAML manifest, including configuring min and max replicas and CPU utilization targets.

Learn how OpenShift manages storage using the Kubernetes persistent volume framework, provisions storage with multiple plugins, and binds it to pods via persistent volume claims.

Explore how OpenShift manages storage by creating a persistent storage volume and mounting it at /data in pods. Verify file contents across multiple replicas as the app scales.

Explore OpenShift persistent storage through static and dynamic provisioning, storage classes, and CSI plugins across AWS, Azure, GCP, OpenStack, and vSphere.

Demonstrates dynamic provisioning in OpenShift via the CSI plugin and storage class, and contrasts static provisioning using persistent volumes with persistent volume claims.

Learn how Kubernetes allocates CPU and memory for pods using requests and limits, and how kube scheduler, kubelet, and resource quotas in namespaces govern usage.

Learn how to set memory and cpu requests and limits for a cart db deployment in OpenShift, deploy via yaml, and verify the running pod before exploring resource quotas.

Discover how resource quotas cap per-project resources in OpenShift, forcing pending pods when limits are reached and guiding you to manage memory, CPU, and storage per namespace.

Create a namespace limit tester, apply a 512 MB resource quota, deploy a 100 MB memory request, and verify quota usage with OpenShift commands.

Explore microservices architecture with a docker-based voting app, featuring a Python voting interface, Redis in-memory store, a .NET worker, PostgreSQL database, and a NodeJS results UI.

Deploy a multi-tier voting application on an OpenShift cluster, configure Redis and PostgreSQL services, run Python and NodeJS apps, and migrate the worker to a Docker build.

Discover how OpenShift templates and catalog items bundle builds, deployment configurations, image streams, secrets, and routes into application stack, created from yaml or json and deployed with oc create -f.

Learn to create an OpenShift custom template for a voting app, packaging builds, deployments, secrets, image streams, services, and routes into a catalog item.

OpenShift teaches how to manage authentication and authorization using users, service accounts, and groups, with roles and namespace bindings for controlled access.

Create and map users and identities in OpenShift, manage service accounts in a namespace via ui or cli, and assign view or admin permissions with groups and role bindings.

Learn how role-based access control enforces authorization to resources in OpenShift and Kubernetes, using roles, role bindings, cluster roles, and cluster role bindings to secure namespace and cluster scope.

Learn how to set up RBAC in OpenShift by creating a namespace role to view pods, creating a pod viewer service account, and binding them with a role binding.

Create a read-only user context in OpenShift by defining a cluster role to view pods and binding it to the user for cluster-wide access.

See how config maps in OpenShift and Kubernetes store key-value configuration data to inject environment variables and runtime parameters, enabling reusable deployments; create with yaml, oc, or kubectl.

Demonstrates creating a carts db config map, defines key-value data like MongoDB user and database, uses value from config map key reference, applies the config map to resolve pod errors.

Learn how Kubernetes secrets store passwords, API keys, and connection strings, how the opaque standard handles them, and why production uses vaults or cloud secret managers.

Explore how to create and reference secrets in OpenShift using yaml, the ui, and the cli, including secret keys like MongoDB_password and secret key refs in deployments.

OpenShift network policies control pod traffic by IP and port in the OSI framework. Learn ingress and egress rules, CIDR examples, and how pods communicate within a namespace.

Explore how Kubernetes APIs are extended by controllers and custom resource definitions, and how OpenShift operators simplify managing containerized apps.

OpenShift sits on Kubernetes as a simplifying abstraction, with OpenShift Local installation and a free sandbox, and covers projects, builds, deployments, routes, storage, quotas, and RBAC across cloud and on‑prem.

Learn source code management fundamentals, including version control, builds, pipelines, and deployments in OpenShift, and practice setting up a local Git environment with GitLab.

Set up a local GitLab instance by creating a CentOS template in VirtualBox, configuring a static IP, installing Docker, and deploying GitLab with Docker for access via the host IP.

Master the build pipeline by turning source code into docker images, testing automatically, and deploying via a docker-based ci/cd workflow from development to production.