►
From YouTube: Creating Custom Operator Catalogs for OpenShift | OpenShift Commons Gathering 2020 KubeCon NA
Description
Creating Custom Operator Catalogs for OpenShift
Karena Angell (Red Hat) Andre Tost (IBM)
OpenShift Commons Gathering KubeCon NA
November 2020
Operators are a great way to package up single applications and features for OpenShift, as well as other Kubernetes based application environments. But what if you could build a custom operator catalog of applications that can be added to the administrator console? Building custom operator catalogs allow you to add an index of applications to be easily accessed and deployed from the console. This session walks through the steps required to create one in OpenShift as well as a demo example of a custom operator catalog using IBM Cloud Paks.
466769 Creating Custom Operator Catalogs for OpenShift
A
A
A
We're
also
seeing
commercial
and
government
industries
that
are
recognizing
the
value
of
these
custom
operator
catalogs
and
having
shared
repositories
for
different
verticals,
such
as
government
energy
manufacturing
and
then
also.
We
have
partners
that
are
creating
solutions
on
top
of
openshift
and
for
these
solutions
to
create
more
value
for
their
customers.
They
are
building
catalogs
and
andre.
Can
you
talk
more
about
that.
B
B
We
have
plenty
of
customers
that
we
work
with,
who
are
running
their
clusters
in
kind
of
a
disconnected
mode
so
that
they
can't
pull
things
directly
from
the
internet,
so
we
needed
to
have
a
way
to
expose
them
in
an
installable
fashion
that
we
could
bring
to
that
cluster.
We
also
wanted,
since
there's
tons
of
operators
already
out
there.
We
wanted
to
kind
of
carve
out
our
own
little
little
space
for
them
and
an
installable,
separate
catalog
actually
helps
us.
A
And
to
show
you
the
the
workflow,
this
is
simplified,
but
you
have
your
custom
catalogs
and
then
you've
created
a
bundle
and
then
you
create
your
docker
file
and
then
you
go
all
the
way
through
and
you
finally
attach
your
catalog
to
openshift.
Now,
don't
worry,
I'm
going
to
walk
through
each
of
these.
A
A
B
A
A
A
A
A
And
then
we
want
to
attach
your
index
image
to
openshift.
Now,
there's
several
ways
that
you
can
do
this
one
of
the
most
popular
is
configuring
your
catalog
source
and
then
go
ahead
and
directly
apply
that
into
your
openshift
cluster
and
now
andre.
Can
you
show
us
that
deeper
dive
demo
into
ibm
cloud
pack,
so
we
can
see
what
it
looks
like
before
you
have
the
catalog
and
then
once
you
do
have
the
catalog.
B
So
we
have
kind
of
a
process
behind
it.
I
have
a
picture
that
shows
that.
So
so
let
me
so
once
the
catalog
is
out
there.
Let
me
show
you
what
that
looks
like,
so
this
is
a
regular,
a
regular
openshift
cluster.
It's
freshly
deployed-
and
you
can
see
here
right
away.
This
is
something
I
sometimes
point
out
that
I
think
makes
it
speaks
for
having
a
custom
operator.
Catalog.
Is
that
here
there's
402
items
in
here,
so
there's
400
tiles
right.
It
makes
it
hard.
B
I
have
filters
here
right
but,
like
I
said
earlier,
we'd
like
to
have
our
own
kind
of
collection
being
able
to
show
our
operators
and
our
tiles
in
there
and
the
way
that
works
is
simply
just
like
karina
was
showing
earlier
I'm
going
to
cheat
here.
We,
in
fact
we
have.
We
have
two
catalog
sources,
so
let
me
put
them
in
here,
so
this
is
one
we
have
a
set
of
common
services,
common
kind
of
things
that
we
share
across
many
capabilities,
so
we
kind
of
group
them
into
their
own
catalog.
B
B
B
So
if
we
go
back
to
the
overview
tab,
we
can
kind
of
see
that
now
it's
pulling
the
images
and
it's
it's
doing
things
the
easiest
way
to
see
if
it
actually
worked,
is
to
just
go
back
to
the
operator
hub
and
wouldn't
you
know
it,
the
first
one
is
out
here:
that's
the
first
catalog
I
created,
and
you
see
that
these
are
more.
You
know
for
auditing,
a
short
manager.
B
We
have
some
support
for
helm.
You
know
those
kinds
of
things.
Let
me
actually
refresh
this
by
now.
The
second
catalog
should
be
there
and
there
it
is.
We
got
19
operators
in
there
right
now
and
again.
This
now
makes
it
possible
for
us
to
kind
of
group
this
in
a
nice
way,
for
only
the
the
things
that
that
we
want
to
have.
I
I
don't
want
to
go
into
the
details,
I'll
just
show
you
an
example,
so
we
have
something
called
the
cloud
pack
for
integration.
We
have
an
operator
for
that.
B
We
can
now
say
install
that
thing,
we'll
put
it
into
a
particular
namespace
and
we
say
install
and
then
it
kind
of
sits
there.
Now
it's
going
to
do
its
thing,
and
what
makes
this
interesting
is
that
our
operators
all
have
plenty
of
dependencies
on
other
operators
that
they
pull
in
as
well,
and
one
of
the
advantages
of
doing-
and
you
can
see
this-
I'm
not
doing
anything
right
now-
it's
pulling
in
all
those
dependent
operators
and
it's
making
sure
that
those
are
installed
as
well.
B
Now
one
interesting
piece
to
this
is
that
at
the
same
time
we
have
these
dependent
operators.
We
also
have
the
common
ones
that
I
that's
the
catalog
I
showed.
First
they
go
into
their
own
namespace,
so
you
can
do
this
dependency
and
deployment
kind
of
automatic
handling
across
namespaces.
It
just
doesn't
need
to
be
just
all
in
one
namespace
and
if
we
were
to
wait,
then
something
would
pop
up
here.
There's
there's
a
whole
bunch
more.
B
It
takes
a
while
for
the
dependencies
to
get
resolved
and
then
pull
down
the
operators,
and
then
they
get
installed.
So
this
all
happens
magically
automatically.
In
the
background,
let
me
go
back
to
the
earlier
ones.
They're
in
this
namespace
here
just
show
an
example
of
where
I
could
now
say.
Well,
here's
one
of
those
that
I
now
want
to
create
an
instance
for
this
is
a
capability
we
have
in
there.
B
It's
called
the
platform
navigator
and
then
I
can
go
in
and
do
some
settings
and
I
hit
create
and
that's
then
actually
going
to
deploy
the
workload
just
wanted
to
show
you
and
I
have
because
that
takes
a
while,
because
it
needs
to
deploy
a
whole
bunch
of
other
workloads
that
are
dependencies
and
so
forth,
and
because
we
kind
of
reflect
the
dependency
chain
that
we
have
with
the
operators
in
the
workloads
as
well.
Of
course.
B
B
I
already
deployed
an
instance
of
it
and
it
shows
that
it's
that
it's
all
ready
to
go,
and
I
can
even
see
the
resources
that
it
that
it
manages
and
so
forth,
and
I
can
go
in
here-
and
one
thing
we
did
is
that
we
also
put
a
console
link
in
here.
This
is
something
that
we're
we've
been
struggling
with
in
the
past.
A
lot
is
where
we
say
we
have
an
automated
deployment
of
something
out
of
whatever
kind
of
catalog,
but
then
how
do
you
know
that
it's
done?
B
How
do
you
know
where
to
go
to,
for
example,
go
to
some
ui
that
then
lets
you
work
with
this.
So
in
this
case
I
just
need
to
go
here
and
here's
our
cloud
pack
and
then
I
can.
I
can
do
my
thing
with
it.
So
that's
all
I
wanted
to
show
in
the
demo.
Like
I
said
this
is
this
is
all
coming
together
in
the
central
process.
It's
it's
then
be
installed.
We
have.
Oh,
let
me
show
you
one
more
thing
here
before
I
forget.
B
B
B
B
We
have
been
doing
this
for
a
while
we're
an
active
member
of
the
operator
framework
community
and
the
sdk
community,
because
there's
there's
new
things
emerging
and
that's
been
very
helpful
for
us
to
have
that
kind
of
exchange
there
with
the
people
that
are
writing
the
code
to
see
what's
coming,
and
how
could
we
utilize
it?
I'm
not
going
to
go
through
the
details
of
this
slide
here.
B
Just
wanted
to
bring
it
up
to
show
that,
if
you're
in
any
kind
of
scalable
environment,
then
you
need
to
have
a
ci
cd
process
for
this
right.
If
you
go
back
to
what
karina
showed
earlier,
this
is
you
know
you
you
build
bundles,
you
build
the
index
and
so
forth.
Obviously,
all
of
that
needs
to
be
automated
because
you
want
to
do
this
kind
of
on
a
continuous
basis,
so
we
have
a
whole
elaborate
kind
of
process
developed
for
this.
B
We
then
upload
this
into
in
our
case
docker
hub,
and
that's
then
leads
you
to
this
catalog
source
that
we
saw
earlier.
So
one
recommendation
I
would
always
make
is
start
thinking
about
how,
if
you
make
the
building
of
the
catalog
or
let
me
rephrase
this
you-
you
want
to
make
the
building
of
your
catalog
kind
of
a
first
class
citizen
in
your
development
process.
B
B
I
mean
we're
building
commercial
offerings,
but
I
would
assume
that,
even
if
you're
like
building
in-house
applications,
for
example
and
building
operators
for
those,
you
still
want
to
have
a
strategy
as
to
how
you
version
things
and
how
you
want
to
make
sure
you
can
do
up
updates
and
so
forth
in
here.
This
is
just
an
extract
from
an
internal
rulebook.
B
If
you
will
that
we
have
defined
and
we're
shipping
that
to
all
the
development
teams
and
basically
saying
here's
how
you
do
versioning
here's,
how
we
do
upgrades,
because,
obviously
the
first
step
is
the
initial
install
like
what
I've
just
shown.
But
then
the
question
is
what,
if
a
new
version
comes
along
and
how
do
we
reflect
that
accordingly
in
the
in
the
respective
olm
data?
So
there
again,
the
recommendation
being
you
want
to
have
a
versioning
strategy.
B
That
means
to
us-
and
maybe
that's
special,
to
a
commercial
offering
like
ourselves,
but
we
also
need
to
now
see
how
can
we,
on
the
one
hand,
have
a
long
supported
kind
of
channel
and
and
branch
and
at
the
same
time,
have
the
ability
to
have
additional
new
versions
come
out
that
maybe
have
a
shorter
support
window?
So
in
that
respect,
we're
almost
mirroring,
if
you
will
what
what
openshift
does
again
with
4.6
that
sticks
around.
B
For
I
don't
know
18
months
or
so
so
we
need
to
have
versions
of
our
software
that
support
it
for
that
long.
At
the
same
time,
we
want
to
be
able
to
have
new
versions
on
top
of
that,
so
there
again,
I
feel
like
every
time
or
in
our
experience
I
feel
like
once
we
got
past
the
initial.
How
do
you
build
a
catalog
source
and
put
it
in
there,
which
is
not
that
hard,
then,
where
we
spend
most
of
the
time
now,
is
to
talk
about
topics
like
this.
How
can
we
automate
this?
B
A
Thank
you,
andre.
It's
been
really
great,
working
with
partners
like
ibm
and
andre
in
particular,
and
all
their
teams,
and,
as
he
mentioned,
they're
involved
in
the
upstream
communities
and
they've,
been
really
adding
a
lot
of
features
to
the
openshift
container
platform
like
a
lot
of
the
other
partners
and
customers
out
there.
So
please
join
us
and
the
operator
framework
dot,
io
you'll
find
all
kinds
of
information,
as
well
as
the
index
image
builder.