►
Description
Behind The Scenes at OpenShift Commons
hosted by Michael Hausenblas
Interview with Alex Clemmer (Pulumi)
A
B
So
I
work
at
a
company
called
plumie
these
days,
I
am
going
to
show
you
a
couple
slides,
not
a
lot
of
slides,
just
because
this
is
the
demo
that
I'm
gonna
show.
You
is
adapted
from
a
talk
that
I
normally
give.
The
talk
is
somewhat
bombastic.
We
called
cube
controllers.
Not
enough.
Can
you
see
those
slides
by
the.
B
B
B
So
a
good
example
of
this
is
like,
if
you
have
a
helmet
art-
and
you
want,
you
know,
you're
running
like
a
nodejs
application
or
something,
and
you
want
to
run
using
some
host
database
like
Amazon's,
RDS
or
Asher's,
cosmos,
DVD
or
Google's
cloud
sequel,
there's
an
extra
step
in
there
in
order
is
it
so
like?
Let's
say
you
have
a
helm
shirt,
you
have
to
somehow
provision
the
cloud
sequel
or
RDS
database.
Then
you
have
to
once
it's
done.
You
have
to
parse
the
connection
string.
B
Then
you
have
to
lunge
that
somehow
into
a
kubernetes
secret
and
then
you
have
to
cube
control
apply
all
of
that
into
into
the
kubernetes
api
server
and
the
right.
So
the
question
I
want
to
ask
is:
is
there
a
more
principled
way
of
doing
stuff
like
this
stuff
that
doesn't
fit
inside
the
kubernetes,
the
normal
kubernetes
api?
Is
there
a
way
to
build
a
principled
workflow
that
helps
us?
Do
things
like
this,
which
I
believe
are
very
common?
Does
that
kind
of
make
sense
so
far,
yep.
B
The
connection
string
must
I
do
that
in
in
bash
or
Python
or
can
I
have
a
principal
dancer
with
with
reasonable
safety
guarantees?
And
this
sort
of
thing
I
think
this
makes
more
sense
when
we
look
at
code,
so
yeah
I
was
thinking
we
might
just
dive
right
in
okay,
so
I'm
going
to
show
you
the
to
begin.
The
simplest
possible
example,
which
is
which
is
taken
directly
from
the
kubernetes
hello
world
example,
there's
no
editorial,
no
opinions,
it's
not
abstracted
in
any
way.
It's
like
literally.
A
A
B
Much
better,
oh
okay,
awesome!
Let
me
know
if
it
breaks
up
again
yeah,
so
so
this
is
the
hello
world
example
from
the
kubernetes
Doc's.
The
hello
world
example
is
basically
an
engine
X
container
that
is
exposed
to
the
Internet
using
a
kubernetes
service.
So
we're
exposing
you.
You
know
port
80.
If
you
know
much
about
like
the
normal
kubernetes
api,
this
should
look
pretty
familiar.
This
is
just
a
normal
deployment.
No
no
libraries,
nothing
between
you
and
the
kubernetes
api,
and
this
is
just
a
normal
kubernetes
service.
Now
a
thing
that
I.
B
So
the
the
the
reason
I
show
this
to
you
is
to
just
give
you
a
flavor
before
we
jump
into
some
of
the
more
interesting
examples.
A
couple
of
things
that
I
would
point
out
is
like
because
we're
using
this
in
this
case
as
typescript,
because
we're
using
typescript
you
can
hover
over
symbols,
get
documentation
get
some
times
what
the
arguments
it
takes.
The
I
start
editing
the
text,
I
can
do
like
engine
echo
dot
and
I
can
get
all
these
all
these
pipe.
B
So
so,
if
I,
if
I
step
back
for
a
second,
when
I
say
that
plumie
is
a
collection
of
SDKs
that
allow
you
to
manage
infrastructure
with
code,
what
I
mean
is
that
there
is
a
pluggable
layer
for
for
in
for
implementing
the
SDK
using
multiple
languages.
So,
right
now
we
support
several
languages,
specifically
in
the
Python
Java
Script
in
typescript
cool.
So
what
I'm
using
now
is
my
favorite
of
these,
which
is
typescript,
which
is
like
a
strict
superset
I,
believe
a
strict
superset
of
JavaScript
that
allows
you
to
provide
type-ins.
B
I've
got
it
so
so,
in
other
words,
what
will
happen
is
if
I
have
a
program
like
this
and
it's
like
a
dot
JS
file,
the
typescript
compiler
will
try
to
infer
the
types
of
each
of
these
variables
right,
so
it
finds
out
that
this
is
a
string,
and
this
is
you
know,
a
goober
nettie
Kate
stock,
V,
1,
theta,
1,
dot
deployment,
etc.
So
you
can
think
of
it.
For,
for
the
purposes
of
this,
demo
is
just
being
a
node.js
program
that
defines
infrastructure.
It
makes
sense,
yep.
A
B
Ok
cool,
so
the
nice
thing
about
using
typescript.
The
reason
why
I'm
using
it
is
because
stuff
like
autocomplete
so
like
I
was
showing
you
before
I
can
I
can
just
dot
into
stuff
and
it
calls
up
actually
the
exact
kubernetes
docks
right
at
your
fingertips.
So
this
is
all
of
these
types
are
generated
directly
from
the
kubernetes
open,
API
spec.
So
the
documentation
that
you
see
here
when
you,
when
you
hover
over
this
stuff,
is
the
documentation
you'd
see
if
you
go
to
the
kubernetes
dot,
you
know
docs
website,
but
where.
A
B
That's
a
great
question:
the
the
the
way
that
this
works
is
that
we
aggregate
several
API.
We
are
projecting
all
API
versions
of
all
objects
into
the.
So
so
what
that
means
is
that
the
kubernetes,
the
the
API
objects
are
really
I'm,
gonna,
say
stable.
That's
not
quite
the
right
word.
They're
stable
in
the
sense
that
V
1,
beta
1,
slash
deployment,
will
always
refer
to
you
and
beta
1/2
point
and
V
1
slash
deployment
like
apps
V,
1
deployment.
B
A
A
B
From
the
perspective
of
the
SDK
well,
getting
will
see
an
example
of
what
happens
when
we
deploy
it
in
a
second
but
okay
from
the
perspective
of
the
SDK.
What
you
as
the
user
do
is
you
just
write
code
against
some
API
version
of
an
object
and
then,
when
you
try
to
deploy
that
to
the
API
server,
we
have
really
nice
tools
that
tell
you
whether
or
not
that
first
of
all
that
API
object
is
even
sensible
to
deploy
that
server
like
doesn't
actually
support
it.
B
A
B
It
so,
okay,
so
world's
simplest
example,
literally
just
an
engine
X
container
that
is
exposed
to
the
Internet
some
service.
What
I'm
gonna
do
now
is
I'm
going
to
come
over
to
my
my
handy,
console
and
I'm
going
to
start
I'm
going
to
start
the
process
of
deploying
it
so
Kumi
update,
so
paluma
t
the
sdk
is
driven
primarily
by
the
pulling
me
command
line.
There
is
a
bunch
of
stuff
going
on
here,
I'm
running
a
diversion,
so
there's
this
warning
here.
B
Don't
just
don't
pay
attention
to
that,
but
one
of
the
nice
things
about
the
plumie
command
line
is
that
it
tells
you
what
it's
going
to
do
before
it
does
it
so
there's
this
whole
planning
phase
where
it's
like
I'm
going
to
create
an
appointment.
That's
going
to
be
called
this
I
am
going
to
create
a
service.
It's
going
to
be
called
this
and
if
I,
if
I,
if
I
expand
the
details
option,
you
can
see
that
these
are
really
just
honest-to-god.
Kubernetes
objects
right,
so
this
appointment
yeah.
B
So
if
you,
if
you
pass
computed
values
or
whatever
it'll,
show
you
the
results
of
these
values?
Okay,
so
so
this
is
like
the
final
version
of
the
DES
point
that
we're
going
to
deploy,
and
this
is
the
final
version
of
the
service
we're
going
to
deploy,
and
so
when
I
said
earlier,
that
this
I
believe
that
it's
possible
to
still
maintain
the
valuable
declarative
aspects
of
the
API.
B
This
is
basically
what
I
mean:
I
mean
that
once
you
pass
the
JSON
to
the
constructor
for
the
deployment
object,
you
get
like
a
well-formed
object
that
you
can
preview,
and
you
know,
because
the
way
the
programming
model
is
constructed,
that
that
the
planning
phase
is
going
to
accurately
report
what
is
going
to
happen
to
this
object.
Okay
and
we'll
see
we'll
see
we'll
get
more
of
an
intuition
for
that
in
a
second,
but
for
now
I'm
just
going
to
deploy
this
and
there's
a
couple
of
things.
So
there's
that
warning
again
about
the
diversion.
B
But
there
are
a
couple
of
things
that
I
want
to
point
out,
which
is
that
the
command
line
actually
gives
you
really
fine-grained
information
about,
what's
happening.
So
so,
because
we
have
semantic
knowledge
of
what
a
deployment
is.
We
know
what
phases
it
goes
through.
We
know
that
the
container
is
going
to
you
know.
If
we
need
to
create
a
replica
set.
We
know
that
we
need
to
boot
up
some
number
of
pods
and
then,
if
any
of
those
errors
out,
we
can
report
that
back
to
the
user.
B
But
though,
in
the
case
of
the
service,
it's
going
to
try
and
target
some
number
of
pods
all
services
except
type
external
IP
target
some
number
of
pods.
So
it
knows
to
look
for
that
first
now,
because
this
is
a
type
load
balancer,
it's
waiting
for
us
to
allocate
an
IP
address,
and
once
it
does,
we
can
see
that
it
has
successfully
completed.
B
Output,
front-end,
IP
and
I
will
pipe
that
to
PE
copy
and,
if
I
go
to
my
handy-dandy
browser,
let's
use
Safari
and
I
paste
that
here
it
takes
me
to
the
nginx,
the
nginx
landing
page.
Ok,
now,
there's
okay,
so
so
that's
the
first.
In
most
simple
example,
just
to
give
you
a
flavor
of
the
general,
the
general
workflow,
what
I
want
to
show
you
next
is
a
little
bit
more.
B
The
main
difference
is
that
we're
creating
a
config
map
out
of
a
file,
so
FS
read
file,
sync
to
string
that
reads:
the
file
default
com
puts
it
inside
the
convict
naps.
Okay.
So
if
I
go
into
default
calm,
this
is
just
a
vanilla,
nginx
conflict
file.
You
don't
really
have
to
know
the
syntax.
Just
that,
what's
important
to
know
is
that
this
is
basically
setting
up
in
nginx
to
forward
traffic
to
google.com
okay,
so
so,
if
I,
so
what
I'm
going
to
show
you
first
is
I'm
going
to
actually
just
provision.
B
So
right,
so
this
is
pretty
much
the
same
thing
as
you
saw
before,
except
this
time.
We
have
this
additional
convict
nap
I'm,
going
to
deploy
that,
because
I
want
to
come
back
to
it
in
a
second
and
show
you
what
happens.
Basically,
what
I
want
to
do
is
I
want
to
take
this
nginx,
calm
and
I
want
to
take
these
two
places
where
we're
we're
configuring
nginx
to
proxy
traffic.
Google.Com
and
I
want
to
change
those
to
proxy
traffic
instead
to
paluma
dot,
IO,
okay
yeah.
B
So
so
what
we're
gonna
see
in
a
second
when
I
do
this
when
I
change
this
file
is
that
is
that
when
we
run
plumie
update
again
it
will
this,
you
know
you
will.
We
will
read
the
file
from
from
that,
and
then
it
has
to
be
the
config
map.
We
will
see
what
the
change
is
and
then
we
will
see
the
change
ripple
through
to
the
deployment
as
well.
B
The
reason
I
point
out
this
example
I
just
want
to
prove
that
I'm,
not
a
liar
by
by
taking
this
deck
and
actually
going
to
the
browser
and
yeah
okay.
So
that's
Google,
calm,
yeah,
right,
okay!
So
now,
if
I
now
here's
the
thing,
that's
kind
of
subtle,
if
you,
if
you,
if
you
didn't
know
if
you
update
a
config
map
in
place
in
kubernetes
by
default,
this
doesn't
actually
trigger
a
deployment
among
the
pods
that
referenced
it
right
yep.
So
this
is
a
common
gotcha.
B
Is
that
is
that,
if
I,
if
I
change,
google.com
to
let's
say
Polly
me
calm
and
then
I
replace
all
we're
going
to
watch
as
paluma
is
smart
enough
to
to
show
us
what
happens
when
we
change
that,
so
so,
basically,
what
it's
going
to
say
is
we're
going
to
replace
the
original
config
map
and
then
we're
going
to
update
the
deployment
and-
and
so
what
does
that
mean?
So,
if
I
drill
into
the
details,
let's
take
a
look.
So
basically
what
a
little
happen
is?
B
You
can
see
that
we're
going
to
create
an
entirely
new
config
map
that,
with
the
new
nginx
conflict,
that
points
at
Polly
me
comm
instead
of
google.com
and
then-
and
this
is
the
critical
part-
we're
going
to
update
the
pod
spec
template
in
the
deployment.
The
point
at
this
new
config
map,
but
the
interesting
thing
about
this
is
you
can
also
see
that
the
delete
is
scheduled
for
after
the
rollout
is
successful.
So
only
after
the
deployment
succeeds
and
the
role
adder
is
complete.
Will
we
delete
the
old
version
of
the
config
map?
A
B
Yeah
yeah,
so
you
definitely
can
so
the
way
that
this
dependency
is
actually
modeled.
That's
actually
a
great
question
is
we
we
have
this
config
map
right
and
when
we
get
the
name
of
the
config
map,
so
this
is
just
nginx,
config
metadata,
dot
name.
We
have
this.
This
variable
engine,
ex-convict
name,
which
is
of
type
plumie
output
stream.
B
Now,
when
we
pass
that
to
the
volumes
to
the
deployment,
so
in
the
point
there's
this
array
of
volumes
that
we
want
to
mount
and
there's
a
reference
to
the
config
nap
and
what
Pulu
me
will
do
is
it
will
unpack
this
output
of
T
string,
which
is
the
the
name
and
it
will
put
the
computed
value
inside
this
field,
conflict,
yeah,
okay!
Does
that
make
sense?
God
yeah
right?
So
so,
if
we,
if
we
go
back
to
the
thing,
we
can
see
exactly
what
that
is
right.
B
So
here's
the
config
map
member
here's,
the
old
version
of
the
config
map
right
engine,
X,
H
GMT.
You
know
we
can
see
that
we're
going
to
delete
that
here
and
we
can
see
that
the
new
name
is
the
same
as
yeah
yeah.
Well,
it's
it's
the
same
/
yeah!
So
here
it
is
so
so
we're
changing
the
name
here
so
the
way
that
it
tracks
this
is
that
it's
you
declare
the
dependencies
using
code
and
then
plumie
will
keep
track
of
references
to
two
other
objects.
Oregon
cool.
Does
that
make
sense?
B
So
far,
awesome
awesome,
yeah,
yep,
okay!
So
let's
go
ahead
and
roll
this
update
so
we'll
see.
Actually
this
should
be
quite
a
bit
quicker
because
we
just
need
to
create
a
new
config
map,
we're
going
to
wait
for
the
deployment
to
roll
out
it's
pretty
fast
and
then
we
deleted
the
original
and
it
succeeded.
So
if
I
do
run
into
IPP
copy
and
then
we
go
back
to
the
browser,
if
it's
not
cached,
it
should
point
at
coulee
me
calm
or
it
will
point
at
that:
I'll
open
it
embrace.
Instead.
B
Okay,
so
it's
proxy
to
pull
me
calm
right,
okay,
so,
okay,
so
that
gives
you
I
hope.
This
gives
you
sort
of
a
flavor
of
what
I
mean
when
I
say
that
it
maintains
the
declarative
aspects
of
the
kubernetes
api,
but
still
lets
you
model
complex,
orchestrated
deployments
right.
So
what
I
write
so
like
this
is
still
declarative
in
the
sense
that
when
we,
when
we
pass
this
data
to
the
config
NAP
constructor,
that's
it
right
like
that
is
the
that
is.
B
It
still
lets
you
do
fairly
interesting
things
and
automates
some
of
the
things
that
would
normally
just
be
like
shelling
out
to
Python
or
something
to
munch
up
right,
yeah,
okay,
so
if
that
makes
sense,
the
final
example
that
I
have
is
is
the
example.
I
talked
about
first,
which
is
actually
quite
different.
This
is
much
more
complicated,
even
though
the
code
doesn't
look
like
it.
Basically,
what
we're
going
to
do
here
is
we're
going
to
create
a
cosmos
DB
instance.
B
Okay,
so
cosmos
DB
is
like
a
flavored
document
store
put
out
by
a
sure,
and
so
I
told
you
before
we
haven't
really.
We
haven't
really
seen
many
examples
of
it
yet,
but
I
told
you
before
that
Combe
is
actually
a
toolkit
for
general,
clutter
infrastructure
programming.
We
support
AWS,
Escher
and
GCP,
and
this
is
a
good
example
of
that,
so
cosmos
DB
is
is
going
to
be.
What
we're
going
to
do
is
because
we
have
some
knowledge
of
the
initialization
semantics
of
cosmos
DB.
We
can
take
that
and
we
can.
B
We
can
write
a
function
called
parse
con
string
and
we
can
pass
the
cosmos
DB,
like
the
normal
cosmos,
DB
connection
strings
to
it,
don't
know
if
I
dot
into
that
connection
string,
as
you
can
see,
is
you
know
just
an
array
of
string
basically,
and
so
what
what
we
do
then
is.
Is
this
actually
goes
inside
a
kubernetes
secret?
B
So
so,
whatever
we
parse
out
of
that
we're
going
to
put
inside
this
kubernetes
secret
and
then
we're
going
to
create
a
helmet
that
that
generates
the
that
generate
we're
going
to
to
provision
the
helm
chart
for
the
classic
bitNami
mean
stack.
Example:
it's
basically
a
persistent
to
do
application
and
we
can
see
that
we
have.
B
We
are
calling
the
secret
secrets
and
we're
going
to
pass
the
name
of
secrets
as
a
secret
name
into
the
into
the
helmet
chart
and
then,
instead
of
using
an
in
cluster
installation,
it
will
actually
just
use
this
cosmos,
DB
application,
or
this
cosmos
DB
instance-
does
that
kind
of
make
sense,
yep
yeah.
So
so
this
is
like
the.
This
is
actually
my
one
of
my
favorite
examples,
because
there's
so
much
going
on
here
right,
like
you're
taking
stuff
that
would
normally
be
extremely
extremely
manual
like
provisioning.
B
B
You
get
this
really
connect
program.
'mad
allows
you
to
make
really
concise
programs
that
that
model
this
in
a
very
principled
way
with
you
know,
with
this
really
convenient
notion
of
completion,
semantics
and
stuff,
so
I
wouldn't
boot.
This
up,
except
we're,
also
actually
booting
up
an
IAS
cluster
and.
B
Like
forever
a
few
minutes,
it
can
take
as
many
as
20
minutes.
So
instead
of
booting,
the
sepulcher
show
you
the
code
and
then
point
you
at
the
examples
directory
and
our
thing.
If
you
want
to
see
what
the
kubernetes
the
AKS
cluster
looks
like.
Basically
it's
just
it's
just
another
file.
We
have
like
the
service
principle
password
there's.
B
You
know
standard
SDK,
we
expose
called
a
guru,
container
service,
kubernetes
cluster
and
then
and
that
kubernetes
cluster
is
exported,
and
then
the
cool
part
about
this
is
that
we
export
the
cluster
and
then
what's
called
the
kubernetes
provider.
And
then
we
can
direct
like,
like
this
kubernetes
secrets,
to
actually
be
deployed
on
to
the
cluster
that
we
provisioned
right
so
by
default
by
default.
Pulu
me
will
just
pick
up
whatever's
in
your
cube,
config.
It's
it's
actually
I
forgot
to
mention
this.
B
It's
an
open
source,
the
plumie
engine
and
all
of
the
code
that
you're
looking
at
right
now
is
entirely
open
source.
So
so
so
we
actually
depend
on
the
official
kubernetes
go
clients
to
do
things
like
pick
up
the
you
know,
cube
config
file,
resolve
all
the
values
and
then
decide
which
were
to
deploy
stuff
onto
we
also
expose.
B
B
Let
me
show
you:
we
have
a
github
repository
with
all
of
these
examples.
It's
github.com
slash,
pulling
me
slash
examples.
If
you
would
like
to
take
a
look
at
this
this,
what
we're
calling
the
mean
stack.
Example,
it's
a
dirty
SaaS
mean,
and
it
has
you
know
very
detailed
instructions
for
how
to
get
started.
B
A
Cool
Wow
a
lot
of
questions,
but
some
of
them
regarding,
for
example,
the
awesome
CLI,
which
has
a
lot
of
colors
a
lot
of
interactivity
and
a
lot
of
other
things.
We're
gonna
take
that
off,
because
that's
probably
not
so
much
on
topic,
but
let's
focus
on
the
on
the
the
real
thing,
and
that
is,
if
I,
if
I
understand
it
correctly,
you
know
if
I'm
putting
that
in
layman's
terms,
it's
kind
of
like
you,
you
get
to
choose.
A
You
know
you're,
developing
your
own
environment,
like
you
know
currently
typescript,
JavaScript
and
Python,
then,
potentially
you
you
we'll
support
other
languages
who
knows
and
Euler
you're,
essentially
dealing
with
all
these
cloud
provider,
objects,
resources,
80,
isoka
days
and
three
players
and
in
a
sense,
it's
kind
of
like
glue
code
because
it
actually
allows
you
to
say
you
know.
Permission
is
here:
take
that
here,
I
declare
dependencies
update
them,
not
inventing
a
new
language.
You
reusing
existing
languages.
A
People
are
using
like
okay,
Java
Script,
that
script
and
and
and
bath,
while
still
keeping
keeping
everything
declarative
and
then
essentially
strongly
statically
typed
in
the
in
a
sense
right.
You
already
kind
of
like
see
at
the
time
you're
coding
does
that
make
sense,
will
that
you
know
crash
or
whatever,
rather
than
having
to
depend
on
you
know,
sad
or
whatever
to
sort
of
said
with
end
up
with
a
tool
to
replace.
A
B
Yeah
I
mean
I
think
that's
a
very
act
way
of
putting
it.
What
we're
trying
to
do
is
just
to
make
the
glue
really
fun
to
use
well,
I
should
be
yeah.
I
should
not
go
too
far
down
with
that
in
LG,
but
but
yeah
so,
like
the
I,
think
I
think
what
we're
trying
to
do
is
not
to
replace
kubernetes
or
like
or
anything
like
this.
B
B
That
should
be
an
easy
thing,
and,
and
so
what
we're
thinking
of
is
what
we're
trying
to
do
is
to
to
be
that
layer
between
kubernetes
and
all
the
other
stuff,
and
also
just
to
make
it
easy
to
iron
out
problem
that
cute
like
little
gotchas.
That
kubernetes
has
like
the
fact
that
font
Ignatz
don'ts
don't
trigger
rollouts
yeah.
That's.
A
B
B
The
other
thing
is
like
I
think
when
you
look
at
other
solutions
in
this
space,
like
you
know,
telomer
case
on
it,
I
think
they
tend
to
focus
on
like
the
at
what
I'm
gonna
call
the
app
offering
from
where,
like
really
their
goal,
is
to
make
nice
well
Elms
goal.
It
seems
as
to
like
solve
the
installer
story,
but
stuff
like
case
on
its
job,
is
more
like
to
make
a
really
good,
app
authoring
experience
where
it's
really
easy
to
write,
kubernetes,
enamel
and
stuff,
and
what
I,
what
I,
what
I
think
I've?
B
What
I
I
think
I've
learned
from
my
experience
in
the
in
the
ecosystem
is
that
people
will
put
up
with
pretty
much
any
app
authoring
system
as
long
as
the
workflow
is
really
good,
which
isn't
to
say
that
I
don't
like
helm
or
case
on
it,
but
but
I
think
one
of
the
things
that
that
I'm,
really
interested
in
doing
is
just
improving
the
general
state
of
the
way
that
these
workflows
work
right
like
stuff
like
CI
systems
that
have
to
stitch
together
a
bunch
of
disparate
parts.
Right,
like
the
only
answer
that
really
exists.
B
Right
now,
for
that
is
like
Jenkins
pipelines
that
stitch
together,
a
bunch
of
you
know
like
a
bunch
of
these
solutions
like
helm
and
case
on
it
and
stuff
like
that,
and
so
really
what
we're
targeting
is
like
for
a
place.
That
was
something
that
gives
people
the
tools
to
reason
about
changes
and
stuff
like
that
in
establish
a
provenance
of
what's
gonna
happen
in
the
updated
things
like
I.
A
Guess
the
only
thing
that
comes
close
in
terms
of
that,
like
you
know
it
might
be
a
stretch,
but
the
only
thing
that
I
can
think
of.
Currently
that
comes
close
in
terms
of
functionality,
but
it's
neither
fun
nor
nor
cool.
Is
the
the
service
broker
API?
Oh
yeah.
It
has
essentially
the
same
kind
of
like
okay,
let's
integrate
stuff
that
is
outside
of
cool.
It
is
with
tough
to
run
sequin.
It
is
and,
as
I
said
it's
you
know
it's
powerful,
but
it's
it's
certainly
not
fun.
B
You
know,
like,
like
I,
said
before,
kubernetes
is
historically
competing
with
vash
in
the
sense
that
you
know
used
to
like
literally
SCP
a
tar
ball
over
to
a
server
and
then
like
SSH,
and
it
started
and
I
think
when
you
once
you
replace
all
of
that
with
like
a
restful
api.
It's
such
a
revelation
that
it's
like.
Well,
maybe
we
should
replace
everything
with
a
with
the
rest.
B
Api
right
like
like,
like
the
idea
that
I
have
like
the
service,
catalog
and
I
could
just
like
boot,
off
a
cosmos
DB
instance,
or
an
RDS
instance
and
then
manage
that
from
kubernetes.
I.
Think
for
a
lot
of
people
is
very
appealing.
Our
answer.
I
think
is.
You
know
we
started
work
on
this,
but
I
think
roughly
when
it
came
out
and-
and
our
answer
was
different,
mostly
because
well
I-
don't
want
to
put
words
in
people's
mouths.
B
I
think
one
of
the
nice
things
about
our
approach
is
that
it
lets
people
who
don't
necessarily
only
want
to
run
kubernetes
or
who
don't
want
to
provision
all
of
their
infrastructure
through
through
Nettie's.
It
gives
them
an
answer
that
is
sensible
and
also
the
other
advantage
of
going
like
the
language.
B
You
know,
orchestration
engine
approach
is
that
you
don't
have
to
wait
for
the
cloud
vendors
to
like
write,
a
custom
controller
that
that
allows
your
provision
infrastructure
behind
OS
ba,
but
you
know
for
the
people
who
really
just
want
to
Hue
control,
apply
and
then
receive
infrastructure.
I
think
OS
ba
is
like
a
super
good
bit
and
I'll
be
I.
Think
it's
like
super
compelling
and
I'll
be
very
interested
to
see
where
the
project
goes.
It's.
A
A
B
Back
right,
so
as
an
engineer
selfishly,
the
reason
I'm
going
around
giving
these
talks
is
because
I
would
like
to
have
conversations
with
people
in
the
ecosystem.
Who
who
have
these
problems
and
I'd
like
to
I'd
like
I,
mean
I
would
like
to
engage
with
the
community
more
with
contributions
and
stuff
like
that,
I
am
still
feeling
out
how
much
of
an
appetite
there
is
to,
like
you
know,
perhaps
contribute
some
of
the
stuff
back
some
of
our
learnings
about
how
you
build
stage
deployments
like
this
I.
B
Don't
know
if
the
community
is
ready
for
that.
But
these
are
the
sorts
of
conversations.
I
would
like
to
have
as
an
engineer
who's
who's
trying
to
work
on
repeatable
reproducible
infrastructure
I
should
say
that
we
have
like
a
little
sass
product
that
you
can
use
with
the
plumie
command
line.
I
didn't
demo,
it
I
rarely
demo
it
for
the
kubernetes
people,
because
well,
I,
probably
should
actually,
but
but
there's
like
a
little
sass
that
that
does
things
like
allows
you
to
manage
organizations
of
people
and
like
grant
Auerbach
permissions
and
stuff
like
that.
A
B
B
But
for
for
the
reason
why
I'm
giving
a
way
I
was
interested
in
talking
to
you
about
this
is
because
I
think
there's
a
bunch
of
people
who
listen
to
to
this
program,
who
I
would
like
to
talk
to
you
about
like
they're
real
deployment
problems,
and
so,
if
you
know,
if
people
have
time
to
give
it
a
shot
and
complain
to
me
like
that
would
be
awesome.
I
would
love
to
hear
about
things
that
we
don't
cover.
A
A
A
B
A
B
Right
or
well
so
the
official
landing
page
is
blooming.
Oh
I'm,
not
sharing
my
screen
anymore
yeah,
the
official
landing
page
is
Polycom.
Who
need
is
our
dock
site
for
the?
If
you,
google,
kubernetes
QuickStart
Kulu
me
it'll,
take
you
to
plumie
io,
slash,
quickstart,
slash,
balloon
or
slash
kubernetes,
honestly,
I
think
so.
Those
are
all
good
places
to
start
since
you've
already
seen
a
demo
I
think
maybe
a
better
place
to
start
for
most
of
the
people.
Listening
to
this
is
the
examples
page
that
I
showed
on
github.
B
You
know
I
believe
I
showed
the
exact
example
that
I
you
know
that
you
can
go
to
earlier
in
the
podcast,
but
perfect,
but
I
think
that's
a
good
entry
point,
because
it
gives
you
clear
installation
instructions
and
you
can
sort
of
play
with
the
things
that
I
showed
you
today,
which
is
awesome,
would
be
nice.
It's.