Understanding OpenShift: Flavors, Architecture, and Developer Benefits
Key Points
- OpenShift is a Kubernetes‑based platform for running containerized workloads, with the open‑source core called OKD (Origin Community Distribution) available for free, while Red Hat‑branded OpenShift provides commercial support and multiple deployment flavors.
- The architecture can run on bare‑metal or virtualized hardware, on‑premises or in public clouds, typically atop Red Hat Enterprise Linux (or CentOS for OKD), with Kubernetes as the base layer and OpenShift adding a management layer that includes a web console and CLI to streamline day‑to‑day operations.
- For developers, OpenShift simplifies the workflow by allowing them to create projects and applications via either the CLI or an intuitive web console, offering ready‑made templates for various languages and enabling rapid code pushes to repositories.
- Both developers and operations engineers benefit from OpenShift’s abstraction over Kubernetes, which reduces the complexity of deployment, scaling, and maintenance while maintaining the flexibility to run workloads wherever needed.
Sections
- Understanding OpenShift Flavors & Architecture - In this introductory talk, an IBM developer advocate clarifies the distinction between the free, community‑driven OKD project and the supported Red Hat OpenShift offerings, and outlines how OpenShift can be deployed on various infrastructures with a layered stack that sits atop Kubernetes.
- OpenShift Automated CI/CD Pipeline - A developer pushes code to GitHub, triggering a webhook that starts a Jenkins job in OpenShift to build a Docker image, push it to the built‑in registry, and automatically deploy the new version across the cluster.
- Automating Host Scaling with OpenShift - The speaker explains how OpenShift leverages Ansible Playbooks to automate the addition of new hosts to a cluster, simplifying operations engineers' tasks.
Full Transcript
# Understanding OpenShift: Flavors, Architecture, and Developer Benefits **Source:** [https://www.youtube.com/watch?v=KTN_QBuDplo](https://www.youtube.com/watch?v=KTN_QBuDplo) **Duration:** 00:07:03 ## Summary - OpenShift is a Kubernetes‑based platform for running containerized workloads, with the open‑source core called OKD (Origin Community Distribution) available for free, while Red Hat‑branded OpenShift provides commercial support and multiple deployment flavors. - The architecture can run on bare‑metal or virtualized hardware, on‑premises or in public clouds, typically atop Red Hat Enterprise Linux (or CentOS for OKD), with Kubernetes as the base layer and OpenShift adding a management layer that includes a web console and CLI to streamline day‑to‑day operations. - For developers, OpenShift simplifies the workflow by allowing them to create projects and applications via either the CLI or an intuitive web console, offering ready‑made templates for various languages and enabling rapid code pushes to repositories. - Both developers and operations engineers benefit from OpenShift’s abstraction over Kubernetes, which reduces the complexity of deployment, scaling, and maintenance while maintaining the flexibility to run workloads wherever needed. ## Sections - [00:00:00](https://www.youtube.com/watch?v=KTN_QBuDplo&t=0s) **Understanding OpenShift Flavors & Architecture** - In this introductory talk, an IBM developer advocate clarifies the distinction between the free, community‑driven OKD project and the supported Red Hat OpenShift offerings, and outlines how OpenShift can be deployed on various infrastructures with a layered stack that sits atop Kubernetes. - [00:03:09](https://www.youtube.com/watch?v=KTN_QBuDplo&t=189s) **OpenShift Automated CI/CD Pipeline** - A developer pushes code to GitHub, triggering a webhook that starts a Jenkins job in OpenShift to build a Docker image, push it to the built‑in registry, and automatically deploy the new version across the cluster. - [00:06:17](https://www.youtube.com/watch?v=KTN_QBuDplo&t=377s) **Automating Host Scaling with OpenShift** - The speaker explains how OpenShift leverages Ansible Playbooks to automate the addition of new hosts to a cluster, simplifying operations engineers' tasks. ## Full Transcript
Hi everyone, my name is Sai Vennam, and I'm a developer advocate with IBM.
Today, we want to talk about OpenShift.
OpenShift is a platform that allows you to run containerized applications and workloads
and is powered by Kubernetes under the covers.
Something that I want to clear up, right off the bat,
is the different flavors that are available with OpenShift.
Now the open source project that actually powers OpenShift is called OKD,
or Origin Community Distribution, and you can start with that for free today.
OpenShift, on the other hand, has multiple flavors
and it's an offering that comes with Red Hat support
regardless of where you choose to run your applications and workloads.
Let's take a look at what the architecture of installing and working with OpenShift would look like.
One of the big advantages is being able to take advantage of public or private resources
for running OpenShift.
That includes bare metal or virtualized hardware,
whether it's on-premises or on a cloud provider.
On top of that, we're going to have the operating system
which is generally Red Hat Enterprise Linux,
but you can also use CentOS when working with OKD.
On top of that, we're going to have Kubernetes.
And if you want to learn more about Kubernetes,
check out some of the other great videos that we have.
So, we'll have the Kubernetes layer here.
Finally, this where OpenShift really comes in.
It's a layer that's built on top of Kubernetes,
and makes working with it much easier.
OpenShift takes a lot of the difficult tasks, like deploying applications
and doing things like the day-to-day operations,
easier by building a web console in the CLI,
as well as a facade on top of Kubernetes,
to make all of those tasks just a little bit more streamlined and easy to do.
Let's go with two different types of engineers that really benefit from taking advantage of OpenShift.
We'll start with developers.
So, we’ll sketch out a developer up here.
Now what does a developer have to do?
Well, they generally have to write applications, create changes,
test them out, deploy them into a cluster,
and they're really just focused on that, and any other kind of distractions
will slow them down from that task.
So, with that, the first thing that they're going to want to do when starting with OpenShift
is to create a project and an application.
To do so, OpenShift has two different ways
of enabling developers to work with their platform.
So, one, you can take advantage of the CLI.
And there's also a really powerful web console
that they can work with as well.
So, the first thing that the Dev wants to do
is take advantage of one of those 2 form factors
to create a project and an application,
and there's templates for all different kinds of source code
and programming languages
that the Dev wants to work with.
So, we'll go ahead and do that
and then once they get into a flow of creating updates to an application,
the very first that they're going to want to do
is push changes to a repository.
And in this case, let's use GitHub as an example.
Say that this developer is making changes to GitHub;
that's really all they need to do.
Behind the scenes, OpenShift is going to take care of the rest.
So, when that application or project was created,
OpenShift, in the backend, will create a Jenkins job and pipeline
that helps power deploying this application.
So, once code gets pushed into that GitHub, it will trigger Webhook,
which kicks off a Jenkins job, which is going to do two things:
First, what it is going to do is do something call "sourced image"
which is going to create a Docker image
out of that that source code.
Next, it is going to go ahead and take that and put it into a registry, a private registry,
which comes built-in in OpenShift
and, in fact, you can actually use public registries,
or your own registry, if you have it outside of this context as well.
Once that image gets built and pushed into that registry,
next what OpenShift will do is go ahead and push that
into the actual cluster,
and that's what we've got here is 2 hosts that are in our cluster in OpenShift.
We're going to take that image,
and let's say that we set it up to deploy 2 times
... and we'll call this v1 of the application.
So, let's kind of overview that process one more time:
So, the developer makes some change to a code,
then Jenkins will kind of kick off that build,
create an image,
push that image to a registry
and then, a little bit of a different thing here,
so, in this step right here OpenShift takes advantage of something called image streams,
it's a little bit different to how Kubernetes will do things
and essentially what it enables you to do is whenever a change is kind of detected with that image
an image stream will allow you to push those with no downtime to applications,
so what it will do is, you know, with that new version of that code,
it'll bring down the old version,
start the new version
until we've rolled out the whole new version of that application.
So, this is just a few ways that OpenShift makes developers’ lives easier.
Next, let's talk let's talk about Operations Engineers
and how OpenShift makes their lives a little bit easier.
I'd say there's 2 major things that operation teams really need to worry about on a day-to-day basis,
and it's totally different than what a developer needs to do.
So, for one, they need to maintain a high availability and they need to make sure
things like site reliability engineers do this to make sure the applications are available,
and the infrastructure is healthy.
And to do so OpenShift has that web console that we've talked about
and in addition to the CLI, the web console is a great way for them to
really take advantage and make sure they're getting that
availability number that they're looking for.
So, that's one way that operations engineers benefit from taking advantage of OpenShift.
Next, let's talk about maybe scaling out one of these hosts.
So, let's say that we've taken advantage of all of the load,
or all of the capacity, of these hosts and we want to scale out another one.
The process of scaling up a new host and adding it into the cluster can be quite painstaking,
but OpenShift takes advantage of something called Ansible Playbooks
which are a great way of automating all of those different
tasks that an operations engineer might have to do.
One of them being: scaling up the number of hosts.
So, by taking advantage of an Ansible Playbook,
they can go ahead and spin up the creation of a new host
and bring that into that cluster.
This is just one of the examples of how OpenShift makes Operations Engineers lives easier
in the day-to-day.
Thanks for joining me for this quick overview of OpenShift.
If you enjoyed this video be sure to drop a "like".
If you have any questions, drop a comment below
and be sure to subscribe for more videos in the future.