►
From YouTube: OpenShift Commons Briefing #74: Deploying Multi-Container Applications with Ansible Service Broker
Description
Deploying Multi-Container Applications on OpenShift with the Ansible Service Broker
The Kubernetes Service Catalog and Open Service Broker API are creating a new way for users to provision and manage services on OpenShift through a collection of Service Brokers. One of these brokers, the Ansible Service Broker, is focused on providing a mechanism for allowing applications defined with Ansible to be exposed to the Service Catalog. We call this application definition an Ansible Playbook Bundle (APB); a lightweight definition that is essentially a few Ansible playbooks named for each of the Open Service Broker API methods. The bundle is packaged as a container image with an Ansible runtime for distribution to be consumed by the Ansible Service Broker.
In this talk we will introduce the concept of the Ansible Playbook Bundle and Ansible Service Broker. Additionally, we will walk through a few use cases demonstrating how to define and deploy multi-container applications.
Presenters:
Todd Sanders – Director, Software Engineering
John Matthews – Principal Software Engineer
A
Hello,
everybody
and
welcome
once
again
to
yet
another
OpenShift
Commons
briefing.
We
are
really
seems
to
have
ten
members
of
an
school
team
here
today
to
talk
about
deploying
multicon
to
your
applications
on
open
ships
using
the
Antico
service
broker.
It's
going
to
profit
that,
before
of
asks
a
lot
of
questions
about
and
ask
for
demo
and
some
background
on
all
these
are
happy
to
have
Todd,
Sanders,
John
Matthews
and
a
number
of
other
folks
from
Red
Hat
on
on
the
fifth
call
on
and
we're
going
to.
Let
them
talk
for
about
20-30
minutes.
A
You
can
ask
questions
in
the
chat
and
then
we'll
open
up
for
Q&A.
Afterwards,
all
of
these
presentations
are
recording
and
put
up
on
the
open
ship.
Youtube
channel,
so
you'll
be
able
to
find
this
in
a
day
or
so
I'll
get
them
up.
There
is
lower
than
the
blog
or
open
ship
so
without
much
further
ado,
not
in
John,
go
ahead
and
take
it
away
anyway,
we'll
see
where
we
go.
Okay,.
B
C
B
The
idea
here
is
that
there's
sort
of
two
entities
in
this
architecture
there's
the
service
catalog
and
the
broker
itself
and
the
brokers.
What
we're
really
going
to
talk
about
today
and
the
broker
is
all
about
sort
of
a
couple
different
things.
It's
number
one:
it's
around
sort
of
advertising
services
to
the
Service
Catalog,
so
that
the
Service
Catalog
can
see
a
set
of
services
that
a
service
consumer
could
interact
with
beyond
that,
it's
standing
up
those
services
or
creating
instance
of
those
services
and
then
interconnecting
services
together
or
applications
with
services.
B
So
we
wanted
when
we
started
down
this
path,
to
be
able
to
take
advantage
of
the
investment.
That's
already
out
there
for
a
lot
of
folks
in
the
in
the
area,
advanced
wool,
whether
that's
in
play
books
or
whether
that's
in
roles
that
are
in
galaxy.
We
definitely
wanted
to
be
able
to
take
advantage
of
that
and
use
the
power
of
that
to
stand
up
again
applications
and
services
within
an
open
ship
cluster.
B
So
as
we
as
we
dig
in
here,
a
little
deeper,
there's
really
kind
of
two
two
things
we're
going
to
talk
about
in
terms
of
our
architecture.
The
first
is
the
broker
itself
or
the
ansible
service
broker.
And
again
this
is
an
implementation
of
the
open
service
broker.
Api,
which
we
mentioned
on
the
previous
slide,
and
just
at
a
high
level,
has
the
ability
to
handle
traditional
source
to
image
deployments.
B
The
second
piece
is
what
we
call
the
PlayBook
bundle
and
you
could
sort
of
think
of
the
a
book.
Bundle
is
kind
of
the
fuel
for
the
broker.
This
is
the
application
definitions
that
define
sort
of
hey.
This
is
what
my
multi
container
application
looks
like.
So
the
idea
here
is
a
lightweight
directory
structure
that
contains
a
set
of
playbooks.
If
you
will,
in
its
simplest
form,
that's
really
what
it
is.
The
the
OPA
service
broker
API
defines
a
set
of
really
four
four
lifecycle
actions.
B
There
is
provision,
unproven,
I'm,
sorry
provision,
D
provision,
bind
and
unbind,
and
these
actions
tie
directly
to
playbooks
that
exist
within
the
PlayBook
bundle.
We
then
take
this
playbook
bundle
and
we
package
the
inside
what
we
call
a
meta
container,
but
basically
it's
just
a
a
basic
image
that
has
sort
of
a
minimalistic
either
CentOS
or
rel
image
with
a
ansible
execution
environment
that
sits
on
top
of
it.
Really
all
we
really
need
is
enough
to
run
ansible
decide
is.
B
Is
that
when
the
broker
invokes
the
PlayBook
bundle,
it's
going
to
spin
up
this
meta
container,
execute
the
PlayBook
that
corresponds
to
the
life
cycle
action
you
want
to
run,
which
causes
these
actions
to
be
run
within
your
cluster
and
then
that
PlayBook
dies
and
then
that
container,
that
meta
container
dies
and
goes
away,
and
that
will
become
a
little
bit
more
evident.
Maybe
a
picture
helps
with
that.
So
if
we
take
again
a
look
at
this
picture
in
the
architecture-
and
we
start
in
the
middle
again,
we
see
the
ansible
service
broker.
B
We
see
the
broker
is
talking
to
this
thing,
called
the
Red
Hat
container
catalog,
to
get
it's
the
the
antral
playbook
bundles
these
meta
container,
or
these
application
definition
containers
doesn't
necessarily
it
doesn't
have
to
be
the
Red
Hat
container
catalog.
It
can
actually
be
any
image
registry,
but
the
ants
will
service
broker
is
going
to
reach
out
it's
going
to
discover
these
playbook
bundles
and
it's
going
to
advertise
those
services
to
the
service
catalog,
which
are
they
going
to
show
up
in
the
in
the
UI
so
that
the
service
consumer
can
interact
with
them.
B
So
once
the
service
consumer
says,
hey
I
want
to
instantiate
or
provision
a
particular
service,
let's
just
use
database
as
a
service.
As
an
example
I
want
to
provision
my
database,
they
would
select
that
service
in
the
UI
enter
a
set
of
parameters
or
configuration
options
that
we've
exposed
as
part
of
the
PlayBook
bundle
that
give
them
the
knobs
or
tuning
that
we
want
to
allow
that
customer
to
have
interaction
with,
and
then
it
will
send
that
information
to
the
broker.
B
The
broker
will
then
determine
okay,
it's
this
APB
and
it
will
spin
up
that
meta
container
and
execute
the
appropriate
playbook
corresponding
to
a
life
cycle
action
and
then
that
that
meta
container
will
die,
and
similarly
that
will
happen
for
any
of
the
four
life
cycle
options
that
we've
mentioned
again.
Provision
and
binding
provision
all
about
standing
up
the
service
bind
all
about
interconnecting
things
together.
B
If
you
have
a
set
of
rules
that
exist
already,
and
you
really
want
to
use
those
as
part
of
a
lifecycle
action,
so
you're
provision,
you
can
definitely
take
advantage
of
that
and,
as
part
of
this
texture,
the
idea
here
is
just
give
you
a
simple
way
of
invoking
a
set
of
play
books
at
each
one
of
these
lifecycle
action
points
there's
an
additional
file
at
the
bottom
Lee
as
the
API
yeah
mol.
This
is
all
really
just
it's
a
metadata
file,
that's
used
by
the
broker
information.
That's
in
here
are
things
like.
B
Certainly
it's
the
information,
a
broker
needs
to
know
about
how
to
or
what
image
I
need
to
invoke.
That
represents
this
playbook
bundle,
but
taking
that
further,
it's
also
the
parameters
that
get
exposed
through
the
service
catalog
and
through
its
UI
that
the
user
service
consumer
has
the
ability
to
configure
at
provision
time.
It
also
has
sort
of
a
set
of
dependencies
that
we
can
use
to
understand
when
we
either
connect
services
together
or
what
other
containers
we
need
to
spin
up.
As
part
of
of
this
orchestrated
process.
B
So
again,
taking
a
little
bit
deeper
look
inside
here
if
I
wanted
to
create
an
APB
in
its
most
simplistic
form
sort
of
these
the
steps
that
I
would
go
through
and
again.
This
is
where,
if
we're
talking
about
I
want
to
package
a
service
or
a
set
additional
application.
This
is
really
where
the
work
is
from
a
development
standpoint
to
create
these
PlayBook
bundles
that
we
can
drive
through
the
ansible
service
broker
to
realize
our
applications
of
services
through
this
architecture.
B
So
the
first
thing
I'm
going
to
do
is
I'm
going
to
create
an
APB,
yeah
Mille.
Again,
that's
the
metadata
file
and
then
I'm
going
to
create
the
set
of
Play
books
that
I
I
want
to
invoke.
And
if
we're
talking
about
and
it's
you
know
starting
out-
maybe
I'm
just
going
to
create
the
provision
gamal.
So
I
can
actually
instantiate
my
service,
I'm
thinking
I'm,
then
going
to
run
a.
We
have
an
APB
tool
command
that
you
can,
that
will
point
to
later,
and
it
get
Reap
and
a
github
repo
to
show
you
that.
B
But
we
have
some
tooling.
That
makes
us
easier.
You
you're
going
to
run
basically
a
prepare
and
what
the
prepare
is
going
to
do
is
the
metadata
file,
a
PPI
Hammel.
We
actually
base64
encode
that
and
store
that
as
a
label
on
the
outside
of
the
of
the
PlayBook
bundle
itself.
The
nice
thing
about
doing
that
is.
We
can
interrogate
a
number
of
apbs
without
actually
having
to
download
all
of
them
across
the
wire,
so
it
was
really
kind
of
a
performance
savings
thing
for
us
and
then
essentially
I'm
going
to
build
that
container.
B
So
now,
I
have
this
APB
meta
container.
If
I,
if
I
take
a
little
closer
look
inside
again
APB
IMO
being
that
metadata
file
here,
you
can
see
on
the
right-hand
side
sort
of
an
example.
As
I
mentioned,
it's
got
a
name
and
sort
of
the
image
that
represents
that
APB
again,
the
broker
is
going
to
need
to
spin
this
up
to
execute
the
appropriate
playbooks
for
the
service
that
you're
you're
talking
about,
and
then
additionally
here
you
can
see
some
parameters
in
this
case.
There's
a
namespace
parameter
and
a
message
parameter.
B
Then,
if
we
take
a
look
at
the
provision,
dot
yeah
mol
again,
this
can
be
the
full
playbook
or
can
be
a
entry
point
into
maybe
a
role
that
exists.
The
idea
here,
those
is
that
if
you
look
at
the
tasks
section
you
could
see,
these
are
in
its
most
simplistic
form.
This
can
basically
just
be
the
front
for
a
number
of
those
C
commands
that
probably
everybody
is
already
familiar
with.
B
Then
the
last
thing
I
want
to
point
out
is
obviously
one
of
the
things
which
I
just
showed
was
fronting
a
number
of
OSI
commands.
Well,
we
actually
can
can
do
better
than
that
by
leveraging
ansible
modules.
So
right
now,
there's
some
work
going
on
to
develop
a
set
of
a
set
of
OpenShift
kubernetes
OpenShift
modules
for
ansible
2.4
and
those
are
going
to
allow
us
to
take
a
little
bit
more
advantage
of
the
power
of
an
school.
So
here
you
can
sort
of
see
comparitively
side
by
side.
B
On
the
left
hand,
side
you
can
sort
of
see
where
I'm
directly
invoking
OSI
command
and
then
over
on
the
right
hand,
side
I
doing
the
same
thing,
but
leveraging
a
set.
This
set
of
kubernetes
and
open
shift
modules.
If
that's
interesting
to
you
again,
this
is
all
fairly
new
being
developed.
Now,
I've
actually
put
the
github
link
there
at
the
bottom.
If
you
want
to
go
check
that
project
out
I
encourage
you
to
do
that.
C
C
That's
not
connected
to
anything,
then
in
a
separate
step,
we're
going
to
create
the
database
after
we
have
that
up
we're
going
to
show
how
you
can
do
a
bind,
so
you
can
actually
join
those
two
together
and
that's
really
the
magic.
One
assured
here
is
how
does
bind
work
and
has
it
by
and
get
two
credentials
into
the
right
spot.
C
In
this
case,
we
could
talk
to
you
around
a
container
catalog
docker
hub
clay,
whatever
really
want
to
run
up
there
in
the
registry,
there's
going
to
be
several
APB's
that
would
exist,
and
what
we'll
do
is
we'll
look
at
all
the
images
that
exist
in
an
organization
and
then
we'll
filter
out
which
ones
or
actual
apbs,
and
that's
how
the
ansible
service
broker
builds
up.
The
cattle
of
that
it
will
send
back.
So,
in
this
case
we're
going
to
get
the
Postgres
demo
ATV,
and
we
will
download
that
after
we
have
that
available.
C
The
next
thing
we'll
do
is
we'll
want
to
do
a
provision
of
that.
So
the
answer
service
broker
will
run
that
image.
We
have
the
container
running
and
then
we'll
pass
in
a
provision
to
it
and
we
pass
the
provision
that
will
corresponds
to
the
provision
method
of
the
open
service
broker
API.
When
we
pass
that
provision
in
what
we
want
to
happen
is
we
want
the
provision
gamal
to
execute
and
the
provision
llamo
will
be
responsible
for
doing
whatever
is
needed
to
actually
create
this
Postgres
database.
C
So
at
the
end
of
this,
we've
done
a
1
provision
on
APB
and
we
have
a
Postgres
up,
but
the
Postgres
is
not
being
used
by
anybody.
The
next
thing
that
we'll
do
is
we'll
create
our
Python
web
app.
So
we
have
a
github
repo
and
we'll
do
source
the
image
on
that.
So
we
can
get
the
web
app
running.
But
again,
this
web
app
is
not
connected
to
anything.
So
this
is
the
case
where
we
have
two
services,
but
they're
not
actually
bound.
C
C
So
the
last
thing
just
wanted
to
highlight
when
Todd
was
talking
a
little
about
binds
when
you
think
of
bind
think
of
credentials.
That's
really
what's
happening
over
here.
So
the
workflow
is
that
the
broker
is
provisioning.
That
APB
and
the
APB
is
responsible
for
getting
those
credentials
and
it
returns
those
credentials
back
to
the
broker.
That
makes
its
way
to
the
catalog
and
the
catalog
saves
those
credentials
when
you
do
the
binds
the
binds
will
create
a
secret
and
then
will
inject
the
secret
into
our
application,
and
we
go
through
the
demo.
C
C
One
thing
I
forgot
to
mention
here
is
that
this
is
the
newer
web
UI
for
the
catalog
that
we're
looking
at,
and
you
can
see
that
there
are
several
services
that
do
exist
so
right
now.
What
I
want
to
do
is
I
want
to
take
a
look
and
show
you
what
happens
when
you
launch
an
APB
so
for
this
case,
APB
is
running
in
this
project.
So
let's
just
bring
it
up
and
see
what
it's
actually
doing.
Okay,.
C
So
we're
looking
at
the
logs
right
now
of
the
Postgres
APB
that's
running
and
what
we're
seeing
the
logs
do
it.
The
logs
are
just
show
in
an
output
of
a
playbook,
that's
running,
and
you
can
see
some
steps
here,
we're
creating
a
namespace,
creating
the
volumes
service,
get
set
up
an
image
stream
and
things
like
that.
So
all
its
really
doing
this
is
just
invoking
normal
ansible
code
and
this
ansible
code
is
going
to
be
responsible
for
creating
our
Postgres
database
so
I'll.
C
C
C
C
What
I
want
to
show
you
analogues
down
at
the
end
when
this
completed
you'll
see
something
it
looks
a
little
bit
strange?
It's
this
thing
called
buying
credentials
and
then
bind
credentials.
These
are
just
basic
ste
for
encoding
of
some
data
that
is
needed
for
the
Python
app
to
actually
talk
to
our
database.
Those
would
be
the
typical
things
we
would
see
for
a
URL,
username
and
password
things
like
that.
C
So
the
APD
part
of
it
after
provisions
is
that
it
creates
these
credentials
and
then
it
sends
these
credentials
back
to
the
broker
and
we're
going
to
come
back
and
we'll
see
this
in
the
form
of
a
secret.
After
we
do
a
bind,
let
me
go
back
to
the
demo
projects
and
see
if
everything
is
up
now.
Ok,
so
it
looks
like
I.
Have
my
Python
app
and
I
have
the
database
again.
C
These
are
not
connected
I'm
going
to
look
right
now
at
the
Python
app
and
what
I
should
see
is
I
should
just
see
an
application.
That's
up
with
no
data,
and
in
this
case
that
means
that
I'll
be
looking
at
an
application.
Just
shows
us
a
map.
There's
no
data
points
on
it
once
we
load
the
data
in
here
we'll
see
red
dots,
the
correspond
to
zip
codes
in
there.
So
that's
the
next
thing
I
want
to
do
so.
This
is
where
the
magic
comes
in.
C
C
So
we
have
a
new
secret
that
got
created,
and
this
just
has
the
information
that
you
would
expect
to
connect
to
the
Postgres
database.
So
this
is
the
case
when
we
did
the
binding.
The
Service
Catalog
took
those
credentials
from
the
broker,
and
then
it
created
a
secret
and
inject
it
into
this
namespace,
and
then
it
will
told
the
pod
to
restart.
So
we
can
pick
them
up
so.
C
C
But
just
to
take
a
look
at
what
we
were
doing
in
that
one
Todd
mentioned
earlier:
how
there
are
some
newer
modules
that
have
been
created,
ansible
to
control,
kubernetes
or
open
shift
resources.
This
is
a
good
example
of
one
of
those
APD's,
that's
using
the
newer
modules,
so
it
could
take
a
look
at
this
APB
and
I
have
a
link
up
here
in
github
way
to
take
a
look
at
it.
More
you'll
see
an
example
where
we
are
creating
a
service
in
here
and
now
we're
using
more
of
the
modules.
C
We
also
have
several
other
examples.
We
have
some
examples
of
using
an
external
service
like
with
Amazon
for
RDS,
and
we
have
examples
of
WordPress
and
a
few
other
ones
there.
So
if
you
look
at
fuser
APB
examples,
you'll
find
several
examples
there
that
you
can
run
and
with
that.
That
concludes
what
we
wanted
to
share
with
you.
C
C
A
C
Two
things
that
there's
app
well:
this
will
be
I
guess
in
tech
preview,
4,
3
6,
so
we
will
have
it
in
there.
We
do
have
some.
If
you're
going
to
experiment,
we
have
some
really
early
bills
right
now
that
are
available
just
for
playing
around
and
we
have
an
environment
that
you
can
provision
and
you
can
actually
run
this
through.
I
have
a
link
to
it
on
here.
So
if
you
go
to
an
civil
service
broker,
this
link
that
will
bring
you
up
to
github,
where
we
have
several
other
things
here.
C
The
one
I
wanted
to
show
you
is
our
environment
for
running.
If
you
see
right
here,
this
demo
environment
with
cluster
up
that
will
bring
you
to
projects,
we
have
Kolkata
ASB
and
cat.
Asb
is
an
environment
for
running
the
catalog
and
the
ansible
service
broker.
It's
set
up
right
now
to
run
it's
an
older,
build
of
origin,
older,
build
of
the
service
catalog
we're
in
the
process,
hopefully
this
week
of
updating
it
to
some
of
your
builds.
C
But
this
is
where
I
would
look
at
if
you
want
to
get
a
feel
this
and
start
getting
your
hands
dirty,
we
have
a
set
up,
so
you
can
run
it
on
Linux.
You
can
run
on
Mac
or
also
deployed
ec2
I'll
still
work
through
some
other
options,
but
this
would
give
you
an
environment.
You
can
go
ahead
and
start
playing
with
us.
C
A
A
C
A
B
A
Adams
also
asking:
what
are
the
requirements?
We're
logging,
the
broker?
What
does
it
take
the
hosted
brokering
tape
in
community
in
Cilicia
cluster,
and
it's
all
be
done
via
the
command
line?
Can
I
use
this
to
create
docker
files
in
the
process?
It's
a
long.
You
can
also
jump
in
the
bottom
and
see
some
visa
questions.
It's.
C
Starting
to
read
through
right
now
but
easier
for
us,
so
as
far
as
the
requirements
for
running
this
I'm
running
this
right
now,
just
with
a
local
OC
cluster
up
but
I
did
have
a
modified
version
of
origin.
So
I
could
pick
up
the
newer
web
UI
for
the
Service
Catalog
and
then,
of
course,
I
deployed
the
Service
Catalog
as
well.
I'm,
not
really
we're
too
much
on
the
requirements.
C
I
just
really
a
case
of
this
one
I
need
kubernetes
1.6,
so
I
have
enough
stuff
for
the
Service
Catalog,
so
it's
happy
and
then
their
broker
plugs
into
it.
As
far
as
doing
this
from
the
command
line
yeah,
we
could
do
a
lot
of
that,
so
the
service
catalog
itself
has
a
different
API
server.
So
we
have
another
cube
config
that
talks
to
the
API
server
for
the
Service
Catalog,
and
we
can
interact
with
that.
C
Just
the
normal
cube,
CTL
commands
and
through
doing
that,
we
can
do
everything
that
we
have
to
do
on
the
broker
side,
because
old
interactions
just
through
the
service
catalog.
So
you
can
do
this
through
the
CLI
using
QC
TL
to
the
service
catalog
zone,
API
server,
I
think
the
plan
later
on
is
to
put
it
behind
like
an
aggregated,
API
server.
I,
don't
quite
know
the
details
on
that
right
now,
B
what
else?
A
C
So
we
do
have
some
labels
and
labels
ten
support
versions.
We
haven't
done
a
whole
lot
of
work
with
that.
Just
yet.
So
that's
something
you
probably
have
to
design
a
bit
more
and
as
far
as
modifying
an
existing
playbook.
It's
really
you
could
just
fork
the
repo
I'm
assuming
the
APB
comes
from
a
repo.
You
could
fork
it
make
any
changes.
You
could
just
run
the
stuff,
a
test
it
using
ansible
playbook.
C
C
We're
using
a
service
account
well,
we
will
be
using
a
service
account,
that's
something
that
we're
actually
working
on
this
week.
So
we're
going
to
have
two
service
accounts
that
will
be
held
here.
One
will
be
set
up
just
for
the
broker
itself
and
then
the
broker
will
be
dynamically
karidian
service
accounts
just
to
run
the
ATVs
and
then
revoke
in
the
service
account
afterwards.
A
B
A
B
B
Next
to
that
would
be
the
email
list,
our
our
Sprint's
are
all
out
there
accessible
and
Trello.
So
if
you
want
to
take
a
look
at
sort
of
what's
going
on
where
we're
focused,
that's
a
good
area
and
then
in
terms
of
just
following
along
in
the
development
or
contributing
or
seeing
where
you
can
help
out.
Obviously
all
our
github
repos
are
out
there
as
well.
We
do
try
to
make
a
habit
of
anytime.
We
do
sprint
reviews
or
things
like
that
of
actually
recording
videos.
B
A
A
We're
okay,
too,
but
it
is
there's
a
little.
You
know,
there's
some
kind
of
transitions
going
between
what
is
ansible
container
and
service
broker
and
their
things
so
I
think
this
trip
so
I
think
it
brings
us
close
to
the
end.
There's
one
more
question
that
just
popped
in
there
seems
to
provide
the
same
capabilities
good
things
to
provide
the
same,
some
of
the
same
capabilities
as
template.
How
does
this
prepare
the
contrast
with
clean
slate
yeah.
B
I
think
ansible
is
definitely
you're
going
to
you're
going
to
find
some
shortcomings
and
you're
going
to
definitely
need
to
lean
more
towards
something
that's
better
suited
for
that
I
think
ansible
is
definitely
something
that's
definitely
more
suited
to
handle
more
complex
applications.
The
other
thing
is
as
I
think
there
might
be
instances
where
you
want
to
do
things
off
cluster
or
external
and
I
think
this
technology
gives
you
that
ability
as
well
the.
C
Rds
is
a
really
good
example
of
that,
where
for
Jim
Whitehurst
keynote
at
the
rent
summit,
the
last
demo
that
was
shown,
we
did
that
with
one
of
these
APD's,
and
for
that
case
we
had
a
Python
app.
That
was
on
a
local
machine
and
then
we
provisions
and
RDS
instance
that
was
on
ec2
and
we
just
joined
it
to
so
any
kind
of
stuff
like
that,
where,
if
you
are
doing
something,
that's
partly
cloud
native
and
something
else,
that's
traditional
and
you
want
to
bridge
them.
A
A
The
open
ship
log
log,
OpenShift
calm
is
where
you
can
find
the
deck
which
our
athletes
got
to
fit,
make
a
PDF
version
for
and
linked
in
with
the
video
he'd
be
up
in
the
day
or
show
and
I'll
pass
that
out
to
the
mailing
list
amount
on
the
Twitter's
and
next
week
we
have
a
presentation
from
Zion
Brazil
on
her
meekness.
So
if
you'd
like
to
join
us
for
using
prometheus
right,
OpenShift
that'll
be
next
week's
and
we're
looking
forward
to
a
lot
of
things.
A
B
B
A
There's
lots
of
good
stuff
coming
and
lots
more
room
for
other
demos
so
and
presentations.
So
if
anybody
has
other
topics
that
they
want
to
hear
about
or
have
has
something
that
they
want
to
prevent,
we
do
reach
out
to
me,
via
Twitter,
at
open,
share
common
or
at
Taekwon
V
J,
which
is
a
nice
twitter
handle
and
an
easy
way
to
get
all
of
these
or
just
jump
on
our
slack
gentleman
and
that's
the
question
there.