►
From YouTube: Sponsored Keynote: Recursive Kubernetes: Cluster API and Clusters as Cattle - Joe Beda
Description
Join us for Kubernetes Forums Seoul, Sydney, Bengaluru and Delhi - learn more at kubecon.io
Don't miss KubeCon + CloudNativeCon 2020 events in Amsterdam March 30 - April 2, Shanghai July 28-30 and Boston November 17-20! Learn more at kubecon.io. The conference features presentations from developers and end users of Kubernetes, Prometheus, Envoy, and all of the other CNCF-hosted projects
Sponsored Keynote: Recursive Kubernetes: Cluster API and Clusters as Cattle - Joe Beda, Principal Engineer, VMware
If Kubernetes is the gold standard for managing fleets of applications, what’s the gold standard for managing fleets of Kubernetes clusters? Cluster Lifecycle SIG is taking that challenge head on with Cluster API. Let’s talk about how we improve the upstream experience by bringing declarative APIs to cluster creation, configuration and management.
https://sched.co/MQbY
A
Hello
I'm
so
happy
to
be
here
in
Barcelona.
It
was
about
six
months
ago.
I
was
on
a
stage
just
like
this,
announcing
the
acquisition
for
hep
D
1
to
vmware,
and
but
I
actually
feel
more
more
at
home
here
with
cube
con.
So
we're
gonna
be
talking
about
cluster
api
and
really,
you
know
improving
the
story
for
how
we
launch
and
manage
clusters,
but
doing
it
in
an
upstream
way
all
right.
So,
let's
start
with
cube
up
folks.
Who've
been
with
the
project
for
a
long
time,
probably
have
nightmares
about
this.
A
It's
still
in
there
and
the
lizard
brain
folks
used
to
launch
clusters
using
this,
and
it's
been
there
ever
since
the
the
first
commit
for
kubernetes.
This
is
an
example
of
how
we
like
severely
severely
underestimated
the
difficulty
of
launching
and
managing
clusters.
It
worked
kind
of
early
on,
but
it
was
pretty
clear
that
it
didn't
work
well
because
we
saw
it
an
explosion
of
installers
across
across
the
project
as
kubernetes
started
getting
popular
and
we
started
seeing
adoption
and
the
problem
with
this
explosion
of
installers
that
each
of
them
was
vertically
integrated.
A
So
we
attacked
this
the
way
that
we
attack
a
lot
of
things
in
kubernetes
with
with
layering,
and
so
the
first
thing
that
we
did
is
we
created
this
project
called
cube,
a
DM
cube,
admin,
I,
don't
know
people
say
at
different
ways.
You
know
another
kubernetes
tradition
and
and
the
idea
with
cube
admin
was,
you
know.
We
assume
that
you
have
a
set
of
computers.
We
don't
care
how
you
got
them,
whether
you
stole
them
or
launched
them
on
a
cloud
or
both.
A
And
then
you
you
once
you
have
these
computers
have
a
certain
level
of
prerequisites
installed
on
them.
You
can
then
bootstrap
a
cluster
from
there,
and
so
we
decided
not
to
solve
the
entire
problem
with
cube
admin,
but
only
this
slice
of
like
once.
You
actually
have
things
provisioned
and
it's
actually
been
working
out
really
well.
We
built
it
as
a
toolkit
and
we're
starting
to
see
that
code,
either
directly
or
indirectly
end
up
in
a
bunch
of
different
projects,
a
bunch
of
different
installers.
A
What
we're
doing
now
is
actually
attacking
the
next
layer
down
this
is
that
provisioning?
How
do
you
get
the
machines
that
you're
actually
going
to
be
running
these
things
on
top
of,
and
this
is
through
a
project?
That's
called
cluster
API
and
we're
going
beyond
this
we're
actually
using
kubernetes
to
manage
kubernetes
we're
using
the
API
patterns,
the
control
patterns
that
have
proven
so
well
for
managing
things
like
pods
for
managing
machines,
as
they
run
on
top
of
on
top
of
clouds
and
other
API
driven
infrastructure
all
right.
A
A
This
was
at
the
tail
end
of
cube
con
in
in
copenhagen,
and
it
was
really
great
to
see
so
many
people
at
the
end
of
the
conference
when
everybody
just
wants
to
get
home
so
excited
about
this
technology
coming
together
to
really
discuss
what
we
can
actually
do
as
a
community,
so
actually
I
love.
This
photo
all
right,
so
yeah
slides
didn't
get
updated,
they're
supposed
to
be
a
transparent
background
there.
So
what
is
cluster
API
so
there's
there's
four
sort
of
main
resources.
A
These
are
custom,
resource
definitions,
CRD,
so
they're,
extending
kubernetes
and
first
of
all,
we
start
with
a
cluster,
a
declarative
idea
of
what
you
want
your
cluster
to
be,
and
then
on
top
of
that
or
underneath
that
we
actually
have
a
set
of
resources
for
managing
machines.
The
first
thing
we
have
is
a
machine,
and
so,
if
you
create
a
machine,
there's
a
controller
that
we
call
a
provider
that
then
goes
ahead,
takes
that
machine
and
calls
whatever
API
is
necessary
to
be
able
to
actually
instantiate
it
instantiate
a
VM.
A
A
Machine
sets
actually
deal
with
replicating
these
things
so
that
you
can
actually
expand
and
contract
management
at
type
of
thing
and
then,
finally,
as
we
look
at
not
just
day
one
but
day,
two
of
cluster
management,
you
have
to
think
about
how
do
I
upgrade
my
machines
and
that's
where
a
machine
deployment
comes
into
play
all
right,
so
you
might
think
hey
that
all
sounds
great.
But
how
do
you
run
a
kubernetes
when
you
don't
have
a
kubernetes
right,
like
we
gotta,
you
know
these
things
are
layered
and
we're
using
these
patterns.
A
How
do
you
actually
sort
of
bootstrap
this
stuff
up?
How
do
you
get
to
the
point
where
you
can
actually
run
all
that
stuff?
That
I
just
talked
about
well,
there's
two
different
models
that
folks
generally
use
and
one
of
them
is
easier
than
the
other
than
the
other.
The
first
model
is
that
you
have
some
cluster
that
maybe
it's
a
managed
cluster.
A
Maybe
it's
something
that
you're
doing
in
a
more
manual
way
that
actually
runs
all
the
cluster
API
components
and
then
it
goes
ahead
and
it
manages
essentially
child
clusters,
and
this
is
actually
a
pretty
pretty
common
pattern
and
it's
the
easiest
to
wrap
your
head
around.
But
there's
another
pattern,
and
this
is
something
that's
a
little
bit
more
challenging
and
it's
actually
going
to
come
later
in
the
project
is
essentially
self
hosting.
We're
used
something
like
a
mini
cube
to
get
the
cluster
up
and
running
once
the
cluster
is
running.
You
essentially
pivot.
A
All
the
cluster
API
stuff
from
running
on
mini
cube
to
actually
running
on
the
cluster.
That's
actually
managing
itself
all
right,
so
hopefully
that
wets
your
appetite.
This
is
super
early
technology,
we're
at
a
v1
alpha
one,
but
we
got
that
out
and
we're
really
excited
about
it.
Lots
of
really
great
discussions
going
on
in
terms
of
what
this
is
going
to
look
like
in
the
future
and-
and
hopefully
we
can
really
democratize
how
we
actually
build
and
manage
clusters
for
everybody.