UNIT I

Section 1: About OpenShift: Introduction to OpenShift; Three kinds of Platform;

advantages of using OpenShift; OpenShift architecture; OpenShift components,
benefits of OpenShift

OpenShift

OpenShift is a containerization platform developed by Red Hat that helps organizations deploy, manage,
and scale containerized applications.

 It provides a platform-as-a-service (PaaS) environment that enables developers to focus on

coding while abstracting away infrastructure concerns.
 It is built around the principles of container orchestration and offers a wide range of tools and
features to streamline the development, deployment, and operation of modern applications.
 At its core, OpenShift is based on Kubernetes, an open-source container orchestration platform
developed by Google.
 OpenShift extends Kubernetes with additional tools, services, and features to enhance the
developer and operational experience.
 It enables organizations to harness the power of containers, microservices architecture, and
DevOps practices to build and deploy applications more efficiently and reliably.

Three Kinds of Platform

OpenShift offers three main platform options:

1. OpenShift Container Platform (on-premises or cloud-based)

 OpenShift Container Platform is the on-premises or self-managed version of OpenShift.
 It provides organizations with full control over their OpenShift environment, allowing them to
deploy and manage OpenShift clusters on their own infrastructure.
 OCP is suitable for enterprises that require customization, compliance with specific security
standards, or integration with existing IT infrastructure.
 Organizations using OCP are responsible for managing the underlying infrastructure, including
servers, networking, storage, and updates.
2. OpenShift Dedicated (fully managed OpenShift by Red Hat)
  OpenShift Dedicated is a fully managed platform provided by Red Hat.
 With OpenShift Dedicated, Red Hat takes care of the infrastructure management, including
server provisioning, patching, and scaling.
 This platform is designed for organizations that want the benefits of OpenShift without the
burden of managing the underlying infrastructure.
 OpenShift Dedicated offers a high level of security, reliability, and support, making it suitable
for businesses looking for a managed solution for their containerized applications.
3. OpenShift Online (a multi-tenant public cloud offering)
 OpenShift Online is a public cloud offering that allows developers to access OpenShift's
capabilities without the need to manage the infrastructure.
 It's hosted by Red Hat and provides a multi-tenant environment, where multiple users and
organizations share the same infrastructure.
 OpenShift Online is designed for developers and small teams who want to quickly develop,
test, and deploy applications without worrying about infrastructure management.
 It's a cost-effective solution for projects that require the agility of a cloud environment.

Advantages of Using OpenShift

OpenShift offers several advantages, including:

 Developer Productivity: Developers can easily build, deploy, and manage applications using
various programming languages and frameworks.
 Scalability: OpenShift allows applications to scale based on demand, improving performance and
resource utilization.
 Automation: It provides automation tools for building, deploying, and managing applications,
reducing manual intervention.
 Security: OpenShift offers security features such as role-based access control (RBAC) and image
scanning to ensure application and environment security.
 Multi-Tenancy: Supports the creation of isolated environments for different teams or projects.
 Container Orchestration: OpenShift uses Kubernetes as its orchestration engine, managing
containerized applications efficiently.

OpenShift Architecture
The architecture of OpenShift is based on the Kubernetes container orchestration platform, but it
extends Kubernetes with additional components and features to provide a comprehensive environment
for deploying, managing, and scaling containerized applications. OpenShift's architecture is designed to
handle various aspects of application deployment, networking, scaling, and management. Here's an
overview of the key components and their roles in the OpenShift architecture:

1. Master Nodes: The master nodes are responsible for managing and controlling the OpenShift cluster.
They coordinate the deployment and scaling of applications, manage the scheduling of containers,
and maintain the desired state of the system. The main components on the master nodes include:

 API Server: The central management point for the cluster, exposing the OpenShift API that
users and other components interact with.

 Controller Manager: Ensures that the desired state of the cluster matches the actual state by
managing various controllers that monitor and reconcile resources.

 Scheduler: Assigns work to nodes based on available resources and constraints.

 ETCD: A distributed key-value store that maintains the configuration data and state of the
cluster.

2. Node (Worker) Nodes: The node or worker nodes are where the application containers run. They are
responsible for hosting and managing the actual application workloads. Components on the worker
nodes include:

 Kubelet: Manages the containers running on the node, ensuring they are in the desired state.

 Container Runtime: The software responsible for running containers, such as Docker or
containerd.

 Kube Proxy: Maintains network rules and load balancing for services.

3. Networking: OpenShift provides networking components to enable communication between pods

and services within the cluster, as well as external access. Key networking components include:

 Pod Network: A virtual network that connects pods on different nodes.

 Service: An abstraction that provides a stable network identity for a set of pods.
  Ingress Controller: Manages external access to services, enabling routing of incoming traffic to
the appropriate services.

4. Additional Components: OpenShift introduces additional components to enhance Kubernetes

capabilities and provide a complete platform for developers. Some of these components include:

 Routes: A way to expose services externally and handle URL-based routing.

 Builds: Allows source code to be built into container images and managed in the cluster.

 Templates: Defines a set of resources that can be deployed together as an application.

 Deployments: Manages the lifecycle of application updates, including rolling updates and
scaling.

 Image Registry: A repository for storing and managing container images.

OpenShift Components

Some key components include:

Pods: Smallest deployable units that can contain one or more containers.

Services: Expose pods to the network within or outside the cluster.

Routes: Expose services to external traffic and handle URL-based routing.

Builds: Create container images from source code.

Templates: Define application components and their relationships.

Deployments: Manage application lifecycle, including scaling and rolling updates.

Storage Concepts: Persistent storage options for applications.

Networking Concepts: Concepts like Ingress controllers for managing external access.

Benefits of OpenShift

OpenShift offers a range of benefits that make it a popular choice for deploying and managing
containerized applications. Here are some of the key advantages of using OpenShift:
Developer Productivity: OpenShift provides tools for continuous integration and continuous deployment
(CI/CD), streamlining the development process. Developers can focus on writing code and pushing
changes, while OpenShift handles the build, testing, and deployment processes.

Efficient Resource Utilization: OpenShift's container orchestration capabilities, based on Kubernetes,

allow for efficient allocation and scaling of resources. This ensures that applications use resources
optimally, leading to better resource utilization and cost savings.

Scalability: OpenShift makes it easy to scale applications horizontally and vertically. Applications can be
automatically scaled up or down based on demand, ensuring optimal performance without manual
intervention.

Automation: OpenShift automates various operational tasks, such as provisioning, scaling, and load
balancing. This reduces manual effort and the risk of human error.

Multi-Tenancy: OpenShift supports multi-tenancy, allowing different teams or projects to share the same
cluster while maintaining isolation between them. This enhances security and resource management.

Security: OpenShift emphasizes security by providing features like role-based access control (RBAC),
image scanning, and network policies. This helps secure applications and prevent unauthorized access.

Containerized Applications: OpenShift is built around containers, which offer consistent environments
across different stages of the application lifecycle, from development to production.

Portability: Applications developed and deployed on OpenShift are highly portable. They can run on
various cloud providers, on-premises data centers, or hybrid environments without major modifications.

Enhanced Developer Experience: OpenShift offers a web-based console and CLI tools that simplify tasks
like application deployment, monitoring, and scaling. This improves the overall developer experience.

Ecosystem Integration: OpenShift integrates with various tools and services, including monitoring
solutions, logging frameworks, and external identity providers, enhancing the overall development and
operational experience.

Built-in Monitoring and Metrics: OpenShift provides monitoring and metrics collection tools, enabling
real-time insights into the performance and health of applications and the underlying infrastructure.
Flexibility: OpenShift supports a wide range of programming languages, frameworks, and databases. This
flexibility allows teams to choose the technologies that best suit their applications.

Support and Community: OpenShift benefits from a strong community and commercial support from
Red Hat. This ensures access to resources, documentation, and assistance when needed.

Quick Deployment: With features like templates and automated deployments, OpenShift enables rapid
application deployment and updates, reducing time-to-market for new features.

DevOps Collaboration: OpenShift promotes collaboration between development and operations teams,
fostering a DevOps culture and speeding up the delivery pipeline.
 UNIT I

Section 2: Core Concepts: Understand containers and images; pods, services and
Routes; Builds and streams; Templates; Deployments, Storage concepts;
OpenShift networking concepts

Containers

A container is a lightweight and standalone executable software package that contains everything
needed to run a piece of software, including the code, runtime, system tools, system libraries, and
settings. Containers provide a consistent and isolated environment for running applications, ensuring
that they behave the same way across different environments.

Key characteristics of containers include:

 Isolation: Containers are isolated from the host system and other containers, ensuring that the
application's dependencies and configurations do not interfere with other applications.
 Portability: Containers are highly portable because they encapsulate all the necessary
components. Applications packaged as containers can run consistently across various
environments, such as development, testing, and production.
 Efficiency: Containers share the host system's kernel, making them lightweight and efficient.
Multiple containers can run on the same host without the overhead of running multiple virtual
machines.
 Rapid Deployment: Containers can be started, stopped, and scaled quickly. This agility is
especially valuable in dynamic environments that require frequent updates and scaling.
 Versioning: Containers can be versioned, allowing developers to maintain different versions of
an application and easily switch between them.
 Consistency: Containers ensure consistent behavior across different environments, reducing the
"it works on my machine" problem.

Images
An image is a read-only template that contains the filesystem, runtime, libraries, environment variables,
and other configuration details required to run an application. Images are used to create containers.
When a container is started from an image, it's like launching a new instance of the application with the
exact configuration specified in the image.

Key points about images include:

Building Blocks: Images are the building blocks for containers. They define what a containerized
application consists of.

Layers: Images are composed of layers, which are read-only file systems that represent different changes
to the image. These layers allow for efficient storage and sharing of common components across
multiple images.

Registry: Images are usually stored in a registry, a centralized repository where images can be pushed,
pulled, and managed. Docker Hub and container registries like Red Hat Quay are examples of registries.

Versioning: Images can have different versions, usually indicated by tags. Versioning helps keep track of
different iterations of an image.

Base Images: Base images provide the foundational layer for other images. They typically include the
operating system and basic tools.

Dockerfile: To create a custom image, developers often use a Dockerfile, which is a script that defines
the steps needed to build an image.

This separation between images and containers contributes to the portability, efficiency, and consistency
of containerized applications.

Pods, Services, and Routes: Pods are groups of one or more containers deployed together. Services
enable communication between pods, and Routes expose services externally.

Pods

In OpenShift, pods are a fundamental building block for deploying and running containerized
applications. A pod represents the smallest deployable unit in the cluster and can consist of one or more
tightly coupled containers that share the same network namespace and storage. Pods are designed to
encapsulate a single instance of a running process and the resources it needs to function.

Here are some key points about pods in OpenShift:

1. Container Co-location: A pod can contain multiple containers that share the same network and
can communicate with each other using localhost. This is useful for situations where containers
need to work together closely.

2. Single IP Address: All containers within a pod share the same IP address. This allows them to
communicate with each other using standard inter-process communication mechanisms.

3. Shared Storage: Containers within a pod can share storage volumes, allowing them to exchange
data. This is particularly useful when multiple containers need to access the same files or data.

4. Atomic Unit: Pods are considered the smallest deployable unit because containers within a pod
are scheduled together on the same node. This ensures that they are co-located and can
communicate efficiently.

5. Pod Lifecycle: When a pod is created, all the containers within it are started simultaneously. If a
container within a pod fails, the pod as a whole is considered to have failed, and Kubernetes will
handle pod recovery or scaling based on the defined rules.

6. Use Cases: Pods are typically used to group containers that need to work together closely. For
example, an application container and a sidecar container that handles logging or monitoring
might be placed within the same pod.

7. Single-Container Pods: While pods can contain multiple containers, they can also have a single
container. In this case, the pod provides a minimal wrapper around the single container.

8. Pod Abstraction: Pods provide a layer of abstraction over individual containers, allowing
OpenShift to manage aspects like networking and resource allocation at the pod level.

9. Inter-Pod Communication: To facilitate communication between pods, services are often used.
Services provide a stable IP address and DNS name that can be used to access pods, even as
pods are created, deleted, or scaled.

In summary, pods are the basic units of deployment in OpenShift, enabling developers to package and
manage multiple containers as a single entity. They provide a way to encapsulate and manage the co-
location of containers and enable efficient communication between them within a shared network
namespace.

Services

A Service in OpenShift is an abstraction that provides a consistent network endpoint for a set of Pods,
allowing them to communicate reliably with each other and with external entities. Services play a critical
role in enabling load balancing, service discovery, and consistent networking within the cluster.

Key points about Services in OpenShift:

Stable Network Identity: Services provide a stable IP address and DNS name for accessing a group of
Pods. This abstraction ensures that the network location of Pods can change without affecting how other
components access them.

Load Balancing: Services distribute incoming network traffic evenly across the Pods that belong to the
Service, helping to distribute the workload and improve application reliability.

Service Discovery: Services enable Pods to discover each other using a consistent DNS name. This
simplifies communication between components, as Pods can refer to other Pods using the Service's DNS
name.

Internal and External Access: Services can be used for both internal communication within the cluster
and for exposing services externally to the internet.

Label Selectors: Services use label selectors to determine which Pods they target. Labels are used to
associate Pods with specific Services, and Services route traffic to Pods based on these labels.

Builds and Streams: Builds create container images from source code, and streams provide a way to
deliver and update container images.

Templates: Templates define a set of resources to be deployed together as an application.

Deployments: Deployments manage the rollout and scaling of application changes.

Storage Concepts: OpenShift provides various storage options for applications, including persistent
volumes

Routes
A Route is specific to OpenShift and serves as an ingress mechanism for external traffic to access services
within the cluster. It enables external clients to communicate with services without exposing the
underlying Pod IP addresses. Routes allow for URL-based routing and termination of secure connections.

Key points about Routes:

 External Access: Routes provide external access to services within the cluster by exposing them
to the internet.
 URL-Based Routing: Routes can be configured to route incoming traffic to specific services based
on URL paths or hostnames.
 Security: Routes can terminate SSL connections, ensuring secure communication between
clients and services.
 Integration with Ingress Controllers: In OpenShift, routes work in conjunction with Ingress
controllers to manage external access and advanced routing.

Builds and Image Streams

Builds: In OpenShift, a build is the process of transforming source code, along with its dependencies and
build configuration, into a container image that can be run in a container runtime. Builds automate the
process of creating images from source code, ensuring consistency and reproducibility.

Image Streams: An image stream is a way to manage and track container images throughout their
lifecycle. It allows you to reference a specific version of an image and automatically update to the latest
version when a new one is available.

Key points about Builds and Image Streams:

 Source-to-Image (S2I): OpenShift supports Source-to-Image, a build strategy that automatically

creates a container image from source code without requiring a Dockerfile.
 Build Configurations: Build configurations define how the source code is built into an image.
They include source code location, builder image, and build triggers.
 Image Stream Tags: Image stream tags represent a specific version of an image. They allow you
to reference images using a consistent name, even as newer versions are added.
  Build Hooks: Build configurations can include build hooks, which are scripts that run at specific
points during the build process.
 Automatic Updates: Image streams enable you to automatically update to newer versions of
images when they become available, ensuring applications are using the latest version.

Templates

A template in OpenShift is a pre-defined set of resources that can be used to create and deploy
applications consistently. Templates include configurations for services, routes, deployments, and other
resources needed for an application.

Key points about Templates:

 Reusable Definitions: Templates encapsulate application definitions, making them easy to share,
replicate, and deploy consistently.
 Parameters: Templates can include parameters that allow users to customize aspects of the
application during deployment.
 Declarative Configuration: Templates follow a declarative approach, specifying what should be
deployed rather than how to deploy it.
 Consistency: Templates enable teams to create and deploy applications with the same
configuration and settings, reducing manual error.

Deployments

A Deployment in OpenShift is a higher-level abstraction that manages the lifecycle of application

updates. It ensures that desired replica counts are maintained, handles rolling updates, and allows for
easy scaling.

Key points about Deployments:

 Rolling Updates: Deployments support rolling updates, allowing you to update application
versions with zero downtime by gradually replacing old pods with new ones.
 Replica Sets: Under the hood, Deployments use Replica Sets to manage the number of replica
pods.
  Scaling: Deployments can be scaled horizontally to adjust the number of running instances of an
application.
 Rollback: Deployments provide the ability to easily roll back to previous versions of the
application if issues arise.

Storage Concepts

OpenShift provides various options for managing storage within containerized applications:

 Persistent Volumes (PVs) and Persistent Volume Claims (PVCs): PVs and PVCs enable pods to
request and use persistent storage that survives pod restarts. This is useful for applications that
require data storage.
 Storage Classes: Storage Classes are used to dynamically provision PVs based on the storage
requirements specified in PVCs.
 StatefulSets: StatefulSets manage the deployment of pods that require stable and unique
network identifiers and persistent storage, such as databases.
 EmptyDir Volumes: These are ephemeral storage volumes that can be used within pods but do
not persist data beyond the lifecycle of the pod.

Networking Concepts

OpenShift networking involves managing internal and external communication, often through Ingress
controllers. OpenShift networking concepts play a crucial role in enabling communication between pods,
services, and external resources within a cluster. These concepts ensure that applications can be
accessed and communicate reliably while maintaining security and isolation.

Here are some key networking concepts in OpenShift:

1. Pod Networking: OpenShift provides a virtual network for pods to communicate with each other. Each
pod gets its own unique IP address within the cluster, allowing for direct communication between pods
on different nodes.

2. Service Networking: Services provide a stable network identity for a set of pods. Each service gets a
unique IP address, and requests made to the service's IP or DNS name are load-balanced to the pods
backing the service. This allows for easy service discovery and load balancing.
3. Routes: Routes are a way to expose services to external traffic and provide access to services from
outside the cluster. They act as ingress points and allow external clients to access services securely.
Routes can also perform SSL termination and URL-based routing.

4. Ingress Controllers: In OpenShift, Ingress controllers work in tandem with routes to manage external
access to services. Ingress controllers handle the external traffic, SSL termination, and routing based on
rules defined in the Ingress resources.

5. Network Policies: Network policies are used to control communication between pods and enforce
security rules. Network policies allow you to specify which pods are allowed to communicate with each
other based on labels, protocols, and ports. They provide fine-grained control over pod-to-pod
communication.

6. Service Discovery: OpenShift's networking concepts enable automatic service discovery. Applications
can access other services using the service's DNS name, and OpenShift's DNS resolution directs the
requests to the appropriate pods.

7. Node Networking: Nodes communicate with each other to manage the cluster's state. Node
networking includes communication between master nodes, worker nodes, and etcd nodes.

8. SDN (Software-Defined Networking): OpenShift uses a Software-Defined Networking approach to

manage network communication between pods. SDN solutions help create a virtual network overlay that
abstracts the physical network infrastructure.

9. CNI (Container Network Interface): OpenShift supports various CNI plugins to enable networking for
containers. CNI plugins manage the creation and configuration of network interfaces in containers.

10. Multitenancy: OpenShift's networking also facilitates multitenancy by isolating network traffic
between different projects or namespaces, ensuring that communication is restricted based on security
and access policies.

11. Network Plugin: OpenShift can be configured to use different network plugins, such as OpenShift
SDN, Calico, or Flannel, which determine how network traffic is routed and managed within the cluster.
 UNIT I

Section 3: Installation of OpenShift platform: The servers for

installation; Steps to install and configure an OpenShift cluster; post-
installation step

Installation of OpenShift Platform

Servers for Installation: An OpenShift cluster typically consists of master nodes, worker nodes, and etcd
nodes for data storage.

Steps to Install and Configure: The installation process involves

 Preparing servers,
 Setting up prerequisites,
 Using installation tools (like OpenShift Installer),
 and configuring networking, security, and other settings.

Post-Installation Steps: After installation, additional configuration might include

 setting up user authentication,

 integrating identity providers,
 and configuring storage and networking.

1. Prepare the Servers:

Master Nodes: These control the cluster. Typically, you'll have multiple master nodes for redundancy.

Worker Nodes: These run the application workloads. You can have several worker nodes in the cluster.

etcd Nodes: These store the cluster's configuration and state. Like master nodes, you'll have multiple
etcd nodes for redundancy.

2. Prerequisites:
Operating System: Prepare the servers with a compatible operating system, such as Red Hat Enterprise
Linux (RHEL) or CentOS.

Networking: Configure DNS, ensure that nodes can communicate with each other, and open required
ports.

Firewall and SELinux: Adjust firewall settings and SELinux policies to allow OpenShift components to
communicate.

Container Runtime: Install and configure a container runtime, like Docker or containerd, on all nodes.

3. Install OpenShift:

Use OpenShift Installer: Red Hat provides the OpenShift Installer tool, which simplifies the installation
process.

Generate Installation Configuration: Use the installer to generate an installation configuration file
(install-config.yaml) that specifies parameters like cluster name, networking, and nodes.

4. Run Installation:

Run Installation Command: Use the installer with the generated configuration file to start the
installation process.

Installation Process: The installer provisions the master and worker nodes, configures networking, and
installs necessary components.

5. Post-Installation Steps:

After the installation is complete, perform these additional configurations:

 Set Up Authentication: Configure user authentication and identity providers, such as LDAP,
OAuth, or HTPasswd.
 Configure Network Policies: Implement network policies to control communication between
pods and enforce security rules.
 Create and Manage Users: Create user accounts, assign roles, and manage access to resources
within the cluster.
 Deploy Router and Registry: Deploy an OpenShift router to manage external traffic and an
internal registry to store container images.
  Monitor and Manage Resources: Set up monitoring and logging to keep track of the cluster's
health and performance.
 Customize Default Configuration: Modify default configurations to suit your organization's
needs, including resource quotas, limits, and default security settings.

6. Validate and Test: Check Cluster Health: Use OpenShift CLI (oc) or web console to verify that all
components are healthy.

Test Deployments: Deploy test applications to ensure that the cluster is functioning as expected.

7. Backup and Disaster Recovery: Set up regular backups of etcd data and other critical configurations to
ensure you can recover the cluster in case of data loss or disasters.

UNIT I

Section 4: Configuration of OpenShift platform: Change log in identity

provider; Create and manage users and accounts; Deploy an OpenShift
router; Deploy an internal registry

Configuration of OpenShift Platform

Change Log-in Identity Provider: Configure OpenShift to use external identity providers like LDAP, OAuth,
or Active Directory for user authentication.

User and Account Management: Create, manage, and assign roles to users and groups to control access
within the OpenShift cluster.

Deploy OpenShift Router: Set up a router to handle external traffic and route it to services within the
cluster.

Deploy Internal Registry: Set up an internal container registry to store and manage container images
within the cluster.
Installing and configuring an OpenShift cluster involves a series of steps to set up the necessary servers,
deploy the cluster, and perform post-installation configurations. Below is a general overview of the
process:

Changing the Login Identity Provider in OpenShift

To change the login identity provider in OpenShift, you need to configure the authentication settings to
use a different identity provider. The identity provider determines how users authenticate and log in to
the OpenShift cluster. OpenShift supports various identity providers, including LDAP, HTPasswd, and
OAuth. Here's a general process to change the login identity provider:

1. Access OpenShift Configuration: Log in to the OpenShift cluster as an administrator and access
the cluster's configuration settings.
2. Choose Identity Provider: Choose the identity provider you want to use. Common options
include LDAP, which allows you to integrate with an existing LDAP server, and HTPasswd, which
uses a file-based user authentication mechanism.
3. Configure Identity Provider: Depending on the chosen identity provider, you'll need to configure
relevant settings. For example:
 LDAP: Configure LDAP server details, bind credentials, and user search base.
 HTPasswd: Add users and passwords to the HTPasswd file.
4. Update Authentication Configuration: Update the OpenShift authentication configuration to use
the new identity provider. This might involve editing configuration files or using the OpenShift
CLI (oc).
5. Restart Authentication Components: Depending on the changes made, you might need to
restart OpenShift components related to authentication to apply the new settings.
6. Test Login: Test the new login identity provider by attempting to log in with a user account that's
part of the configured identity provider.

Creating and Managing Users and Accounts in OpenShift:

In OpenShift, user accounts are managed through the OpenShift command-line interface ( oc) or
the OpenShift web console. Here's how you can create and manage users and accounts:
1. Creating Users:

 oc Command: Use the oc create user command to create a new user account. For
example:
sqlCopy code
oc create user < username >
 Web Console: Log in to the OpenShift web console as an administrator, navigate
to "Administration" > "User Management," and click "Add User."
2. Assigning Roles:

 oc Command: Use the oc adm policy command to assign roles to users. For
example, to grant admin privileges:
sqlCopy code
oc adm policy add- cluster - role -to-user cluster - admin < username >
 Web Console: In the web console, you can assign roles to users while creating or
editing user accounts.
3. Managing Passwords:

 oc Command: You can use the oc adm policy command to set or update a user's
password.
 Web Console: Users can often set their passwords through the OpenShift web
console.
4. Disabling and Deleting Users:

 oc Command: Use the oc delete user command to delete a user account. For
example:
sqlCopy code
oc delete user < username >
 Web Console: In the web console, you can disable or delete user accounts from
the "User Management" section.
5. External Identity Providers: OpenShift supports external identity providers like
LDAP, OAuth, and HTPasswd. Users authenticated through these providers can be added
and managed accordingly.