►
Description
Yuvaraj and Vince will explore the ClusterAPI v1 release and the new ClusterClass feature.
A
A
A
So
most
of
the
links
that
we'll
be
accessing
on
muscle,
slides
that
we'll
be
accessing
in
this
session
should
be
available.
There
should
be
available
there,
if
not
we'll,
add
them
later,
and
if
there
is
any
news
that
you'd
want
us
to
cover
from
the
last
week
feel
free
to
add
it
to
the
show
notes
and
we'll
go
over
them.
A
A
A
Okay,
we
can
review.
So
we
just
have
two
points,
not
a
lot,
so
the
kubernetes
123.0
release
is
finally
out.
I
think
it's
been
like
four
days
since
it's
out
it's
been
the
new
features
in
it
have
been
covered
a
little
bit
in
the
last
egik
session
and
we're
going
to
have
a
full
full-length
episode
about
covering
everything.
That's
in
kubernetes
123
release
in
an
upcoming
tgik
episode,
which
is
on
jan
10.
A
So
if
you
are
interested,
please
do
tune
in
to
that
and
the
next
one
is
the
kubernetes
contributor
celebration
is
back
again
this
year.
So
if
you
are
interested
in
participating
in
that
celebration,
which
I
highly
encourage
you
to
please
do
register
yours
register,
please
to
fill
out
the
registration
form.
I
think
it's
in
sin,
mid-december,
sometimes
17th
18th,
I'm
not
sure,
you'll,
have
all
the
details
in
this
page.
It's
linked
in
the
show
notes
and
we
should
be
able
to
register
for
that.
A
Okay,
so
the
agenda
for
today,
so
we
will
be
going
over
cluster
api.
A
few
few
new,
exciting
features
in
cluster
api
and
v1
milestone.
Release
of
cluster
api
cluster
api,
as
a
concept
has
been
discussed
a
few
times
in
various
tgik
episodes.
They've
went
over
plus
api
all
of
its
providers,
the
way
it's
being
used
in
various
companies
which
is
products
and
so
on,
but
for
any
new
folks
who've
joined
us
vince
is
going
to
do
a
very
brief
introduction
for
cluster
api,
for
us,
so
wins
go
ahead
and
stop
sharing.
B
Awesome
from
a
high
level
point
of
view,
the
best
definition
I
can
give
for
cluster
api
is
to
make
kubernetes
cluster
life
cycle
boring
and
what
that
means,
like
you
know,
it
depends
on
like
sometimes
like
the
people
you
ask,
but
from
a
high
level
like
kubernetes,
is
like
very
complex
piece
of
software
and
the
goal
for
the
sig
say.
Cluster
life
cycle
is
to
work
like
across,
like
a
bunch
of
different
points
for
the
whole
life
cycle,
so
create
so
update
zero
operation.
How
do
you
define
your
cluster
day?
B
One
and
day
two
operations
like
to
just
like
upgrade
your
cluster
before
cluster
api?
Introduces
the
concept
of
blood
dancer,
for
example,
to
operate
a
load.
Bouncer
was
a
whole
operation,
and
it
was
honestly
very
scary,
like
if
I
remember
like
when
I
did
it
like
just
like
two
two
years
and
a
half
ago
like
it,
was
a
complex
problem
where,
like
you,
have
to
take
into
account
so
many
variables,
and
so
what
we
ended
up
doing
is
like
automating.
B
The
number
one
point
and
complaint
from
our
users
that
we
have
heard
from
community
is,
for
example,
like
the
your
user
experience
and
that's
something
that
we
are
working
on
right
now.
The
1.0
release
that,
like
you,
rush,
will
talk
in
a
bit
like
about
like
it's.
It's
gonna
contain
like
a
lot
of
improvements
and
it's
we're
just
getting
started
and
because
we
want
to
improve
like
how
you
define
a
cluster
and
like
we
want
to
make
sure
that,
like
defining
a
cluster,
is
like
a
really
really
good
experience.
B
A
A
Okay,
so
far,
thank
you
for
covering
that
win,
so
the
v1
release
of
cluster
api,
so
plus
they
pay
recently
went
through
and
had
a
major
milestone,
release
the
v1
release.
So
it
marks
that
class
api
is
finally
is
production
ready
officially,
and
it
has
moved
on
to
the
v1
beta
1
api
types.
Cluster
api
has
been
operating
at
this
at
the
beta
maturity
level.
A
For
a
while,
and
it's
great
to
see
that
we
are
officially
having
that
label
and
saying
that
yeah
across
api
is
now
we
won
and
it's
ready
and
it's
it's
a
work
of
so
many
people
working
it's
the
culmination
of
so
many
people
working
towards
it.
So
many
contributions
from
different
parts
of
the
community,
different
companies
and
so
on,
and
this
new
release
signifies
and
demonstrates
the
growth
of
the
community,
the
adoption
rate
of
the
community,
the
future
maturity
that
we
have
and
the
commitment
towards
it.
A
A
And
then
we
have
neural
lake,
which
basically
goes
along
with
what
vince
was
saying
about.
Making
the
about
making
the
cluster
api
become
a
tool
so
that
it
makes
cluster
lifecycle
management
boring
right
and
that's
what
they
touch
upon
in
this,
where
they
say
that
they
basically
don't
worry
about
the
underlying
cloud
providers
anymore
and
instead,
basically
rely
on
the
api
types
and
the
declarative
pattern
to
be
able
to
with
managing
clusters
creating
clusters,
and
they
are
also
really
excited
about
the
v1
release.
A
So
the
general
trend
is
that
everyone's
excited
about
the
v1
release
and
we
are
are
really
really
looking
forward
to
where
the
project
goes
and
so
on
and
before
we
move
on.
I
would
like
to
give
a
huge
shout
out
and
a
huge
thank
you
to
everyone
who
has
helped
in
bringing
cluster
api
to
this
point.
The
v1
releases
is
a
huge
milestone
release,
so
a
big
thanks
to
the
entire
community
for
helping
us
get
to
this
point.
A
The
blog
post
is
linked
in
the
show
notes.
So
if
you
want
to
take
a
look,
please
do
go
and
take
a
look
there
now
that
we
have
the
v1
release
like
what
does
it
mean
to
upgrade
to
the
v1
release?
So,
let's
just
quickly
go
over
the
change
set
that
we
have
what
it
means
to
upgrade.
How
can
we
upgrade
and
all
those
things
right?
A
So
the
v1
beta1
types
in
cluster
api
are
actually
very
similar
to
the
v1
alpha
4
type,
so
upgrading
from
the
v1
alpha
4
version
of
crosstalk,
which
is
basically
the
zero
four
x
release
series
to
the
v1
beta1
versions,
which
is
basically
the
one
dot,
zero
x-ray
series
and
the
one
dot
x-ray
series
is
going
to
be
seamless,
it's
going
to
be
really
really
straightforward
and
we
have
tooling
around
it
to
be
able
to
do
it.
So
we
have
cluster
battle
where
plus
api
comes
with
its
own
cli
called
cluster
cuttle.
A
If
you
have
not
taken
a
look
at
it,
please
do
go
and
take
a
look
at
it.
It's
it's
an
amazing
tool
to
be
able
to
interact
with
plus
api
and
all
of
its
components,
while
you're
on
a
management
cluster
right.
So
it
helps
you
and
that
tool
has
amazing
capabilities
to
be
able
to
upgrade
the
versions
of
cluster
api.
B
A
You'll
have
to
take
a
look
at
the
specific
providers
to
be
able
to
see
if
they
actually
do
it.
Some
of
some
of
the
popular
providers
like
vsphere
aws
openshift,
they
do
support
upgrading
from
v1
alpha
3
to
even
beta1.
So
please
do
please
do
try
it
out
and
give
us
feedback
where
we're
always
waiting
to
listen
and
see
how
how
the
project
was
maturing.
A
A
So,
let's
move
on
to
cluster
class
and
manage
topologies.
This
is
like
the
newest,
exciting
feature
in
classic
api
that
I
personally
am
really
interested
in
because
it
solves
a
lot
of
prop
solves.
A
lot
of
ux
adds
a
lot
of
ux
improvements
to
how
cluster
api
is
consumed
and
how
closely
api
is
used,
and
it
goes
along.
The
lines
that
once
is
touched
upon
is
basically
making
the
operations
of
dealing
with
the
cluster
managing
a
cluster
becoming
really
simple
and
really
boring
right,
so
so
to
understand
cluster
class.
A
A
Okay,
so
cluster
class
and
manage
topologies.
So
let's
talk
about
how
clusters
are
created
right
now
in
cluster
api
cluster
api
gives
the
user
access
to
a
lot
of
extensibility
and
configurability
when
creating
a
clusters
using
the
cluster
api
types
and
the
cube
and
cubanium
cube
admin
right.
So
this
means
that
the
user
has
the
flexibility
to
plug
in
any
of
the
types
that
we
care
about
and
configure
a
lot
of
things
when
creating
a
cluster.
A
This
also
means
that
the
user
has
to
create
all
the
objects
associated
with
the
cluster
right,
so
you
have
to
create
a
cluster,
the
infrastructure
cluster,
which
is
basically
an
aws
cluster
or
a
vsphere
cluster,
the
underlying
control
plane,
the
in
from
machines
so
like
vsphere
machines,
aws
machines
and
so
on,
machine
templates
and
so
on,
and
the
machine
deployments
and
so
on.
Right
and
this
could
be
overwhelming
for
new
users
or
even
for
users
who
just
want
a
cluster
right,
and
this
problem
is
really
exaggerated.
A
When
you
have
to
repeat
the
same
step
again
and
again
for
creating
multiple
clusters,
you
have
to
duplicate
all
the
templates
that
you
have.
You
have
to
create
all
the
cluster
objects,
all
the
underlying
resources
like
the
infrastructure,
cluster
cluster
objects,
the
kcp
object,
the
control,
plane,
objects
and
all
the
objects,
and
on
top
of
that,
the
users
now
also
become
responsible
for
managing
all
of
these
objects.
A
Right
then
they
have
to
manage
the
deployments
manage
the
templates
manage
the
control,
planes
manage
cluster
objects,
and
so,
if
the
problem,
the
the
the
surface
of
all
the
objects
that
you
have
to
manage
scales
scales
really
quickly.
When
you
have
a
lot
of
clusters
at
play
and
for
someone
like
twilio
who's
using
hundred
plus
production
classes,
the
number
of
objects
that
they
have
to
deal
with
and
really
really
grows
at
a
really
fast
pace.
A
A
Being
this
collection
of
all
the
templates
that
you
care
about
is
a
new
resource
type
that
is
going,
but
a
new
kubernetes
resource
type
that's
going
to
be
part
of
cluster
api,
and
this
idea
of
having
all
the
templates
grouped
into
one
is
really
really
powerful,
because
at
this
point
the
user
just
has
to
define
how
the
cluster
looks
like
using
the
collection
of
this
template
just
once
and
then
reuse
that
over
and
over
and
over
again
for
creating
n
number
of
clusters.
At
that
point.
A
So
the
surface
of
all
the
objects
that
you
have
to
manage
becomes
really
small.
The
the
number
of
steps
that
you
have
to
take
to
create
a
new
cluster
becomes
really
short
and
the
overall
ux
of
having
to
create
and
operate
all
of
the
clusters
and
all
of
the
underlying
objects
then
becomes
really
really
easy
right.
So
yeah
go
ahead
and
see.
B
Yeah
one
one
thing
to
note
here
is
like
for
these
all
these
templates,
like
in
the
in
the
older
model
that
we've
seen
before,
like
whenever
you
wanted
to
change
like
a
field
in
a
template
like,
let's
just
say
like,
for
example,
you
wanted
to
change
a
machine
deployment
instance
type
from
one
instance
type
to
another.
You
have
to
go
and
create
another
template
and
then
roll
it
out,
which
is
a
really
convoluted
operation
to
do
that.
All
the
time
just
because,
like
the
most
templates,
are
immutable
for
rollback
purposes.
B
A
Cluster
class
really
is
the
pro
solution
for
most
of
the
roller
problems
that
we
have
so
now
that
we
have
a
cluster
class
defined,
which
is
basically
the
fusion
of
templates,
which
define
how
which
defines
how
the
structure
of
a
cluster
is
supposed
to
look
like.
How
do
we
use
it
right?
So
at
this
point,
once
we
have
cluster
class,
the
user
can
is
now
responsible
for
just
creating
one
object,
which
is
basically
the
cluster
object,
which
points
to
the
corresponding
cluster
class
that
the
user
wants
to
use.
A
At
this
point,
the
cluster,
along
with
the
cluster
power
controller,
that's
underlying
in
cappy,
takes
care
of
creating
all
the
underlying
objects.
That
would
really
be
necessary
for
cappy
to
create
the
full
final
cluster
right.
So
the
infrastructure,
cluster
kcp
objects
and
all
of
those
things
so
and
we
have
something
called
managed
topologies
that
is
now
part
of
cluster.
That
is
now
part
of
flusky
api
and
clusters,
and
that
is
the
second
part
of
the
solution.
A
So
what
are
managed
topologies
now
that
cluster
is
the
single
point
of
contact,
a
single
point
of
control
and
it
just
differences
across
the
class,
and
since
we
don't
have
to
deal
since
the
user
doesn't
have
to
deal
with
any
of
the
underlying
objects
right.
All
of
the
all
of
the
objects
that
are
hydrated
blue
are
stuff
that
the
user
doesn't
have
to
really
deal
with
the
control
of
being
able
to
create
all
of
these
objects
and
configure
these
objects
right.
A
The
replicas,
the
replicas,
to
use
the
version
to
use
the
metadata
associated
with
it
like
labels
annotations.
All
of
this
can
be
now
just
defined
as
part
of
the
cluster
object
and
that
topology
definition,
combined
with
the
cluster
class
definition
now
rolls
out
and
then
becomes
part
of
the
entire
cluster
hierarchy
that
we
generally
see
in
in
plain
cluster
api,
so
cluster
class
and
manage
topologies
is
a
ux
layer,
usb
sweetening
layer
on
top
of
plain
cluster
api.
A
So
once
the
first
reconciled
loop
finishes,
the
underlying
objects
will
look
exactly
similar
like
very
similar
to
how
cluster
api
has
been
working
for
a
while.
So
they
will
look,
they
will
look
as
a
flight
cluster
api.
The
eight
simple
vandal
across
the
api
that
we
see
and
since
now
cluster
is
the
single
point
of
con
single
point
of
contact
and
single
point
of
control
for
all
the
operations
that
we
care
about.
A
We
can
do
everything
from
just
the
cluster
object
by
just
modifying
the
cluster
object,
so
it
includes
operations
like
scaling
up
clusters,
scaling
up
control
planes,
giving
down
control
planes,
creating
machine
implements
deleting
machine
performance
scale
of
scale
along
machine
deployments,
and
one
of
my
favorite
things
to
do
right
now
is
basically
perform.
Kubernetes
version
upgrades
earlier
with
playing
classes
api.
It
used
to
be
a
huge
orchestration
that
the
user
was
responsible
for
performing
where
they
had
to
upgrade
the
versions
of
kubernetes
on
each
component
at
a
time.
A
So
that
would
mean
going
ahead
and
upgrading
the
kubernetes
version
on
the
control
plane,
making
sure
it's
all
stable
and
good
and
then
moving
on
to
upgrading
the
versions
and
machine
deployments
and
so
on
now
with
managed
topologies
the
responsibilities
taken
up
by
topology
clusters,
so
the
cluster
itself
will
take
care
of
rolling
out
the
version
upgrade
for
all
for
all
the
components
associated
in
the
hierarchy
for
the
users,
so
the
so
the
ux
becomes
extremely
simple.
So
as
far
as
the
user
is
concerned,
all
they
have
to
do
is
just
change.
A
One
field
in
the
spec
and
the
cluster's
version
is
going
to
update
automatically
a
quick
recap
and
just
highlights
of
what
we
just
covered.
So
cluster
class
cluster
class
is
just
a
collection
of
templates
of
all
edits
that
are
needed
to
be
able
to
create
an
underlying
cluster.
A
cluster
class
can
be
used
to
create
cappy
clusters
of
similar
shape,
multiple
cabby
classes
of
the
similar
shape
by
just
creating
one
resource
and
just
one
resource
which
is
the
cluster
resource.
A
A
So
this
simplifies
the
overall
ux
of
how
you
have
to
deal
with
clusters
and
how
you
have
to
create
clusters
managed
clusters
of
cluster
api,
but
under
the
covers,
it's
just
plain
cluster
api
that
will
that
we
are
all
familiar
with
that
we
all
have
been
using
and
that
we
are
all
that
we
all
know
how
to
extend
and
how
how
to
configure
it
before
we
move
on
to
the
demo.
Let's
see
if
you
have
any
questions,
does
cluster
class
help?
A
So
we
have
a
question
by
rico:
does
cluster
class
help
with
topology
awareness
example,
availability
zones
or
rack,
I
would
say
kind
of
yes,
so
it
depends
on
how
you're
defining
your
cluster
class
right,
so
the
cluster
class?
Can
it
depends
on
how
you
define
your
templates
and
how
you
use
those
templates
within
your
cluster
topology.
A
So
at
that
point
underlying,
as
I
mentioned
so
the
if,
since
it
boils
down
to
plain
cluster
api
at
the
point,
you
have
the
control
to
be
able
to
set
the
appropriate
labels,
I
guess
to
be
able
to
control
where
your
machine
departments
go
and
where
your
machines
go
and
so
on.
Vince
did
you
have
anything
to
add
to
that.
B
No,
I
think
so
kcp
for
if
you
use
kcp
as
a
control
pin
provider
already
like
kind
of
spreads
out
like
onto
their
domain
on
its
own,
the
support
for
each
failure
domain
to
go
into
a
specific
sorry,
very
information
deployment
to
go
specific
failure,
meaning
it
will
come
in
january.
There's
an
issue
open.
So
it
will
definitely
help
with
that
for
sure,
and
we
just
need
to
add
support
for
it.
B
A
A
So
let's
just
take
a
look
at
how
cluster
class
looks
like
this
is
my
cluster
class.
So
I
have
a
cluster
class
here.
It's
called
darker
class
so
far
for
parts
of
the
demo,
I'm
just
going
to
use
the
talker
provider
because
it's
quick
and
we
can
easily
iterate
on
it,
and
but
there
are
some
cloud
providers
that
do
support
cluster
class
at
this
point.
So
we'll
also
take
a
look
at
that.
A
So
let's
just
take
a
look
at
how
cluster
class
looks
like
right,
so
the
cluster
class
spec
first
of
all,
has
a
section
for
defining
how
the
control
plane
looks
like
right.
It
then
specif
has
a
reference
to
the
control
plane
template
here
in
this
demo
I'll
be
using
the
cube
adm
control
plane.
So
I
have
a
reference
to
the
puberium
control,
plane,
template
and
since
this
uses
an
infrastructure
machine
underneath
it,
I
have
a
reference
to
the
docker
machine
template.
A
This
control
plane
object
will
at
that
point
use
and
that
defines
the
control
plane
section
of
the
across
the
class,
then
moving
on
to
the
infrastructure
section
of
the
cluster
class.
So
again,
as
I
said
since
I
will
be
using
a
docker
provider
based
workload
cluster,
I
have
a
reference
to
the
docker
cluster
template
again,
as
I
mentioned,
plus,
the
class
is
basically
just
a
collection
of
all
of
these
templates
right.
Following
that
we
have
a
section
called
workers.
A
This
is
going
to
be
a
list
of
machine
deployment
classes
that
you
can
define
within
the
cluster
class,
so
each
machine
deployment
class
at
that
point
refers
to
the
underlying
machine
infrastructure,
machine
templates
and
the
bootstrap
bootstrap
template.
So
we
have
a
reference
to
infrastructure,
machine
template
to
be
used
and
a
reference
to
the
bootstrap
template
to
be
used.
So
I
have
a
collection
of
I
have
a
list
of
two
machine
deployment
classes
and
both
of
them
are
pretty
similar.
A
This
is
an
example
to
show
that
we
can
have
multiple
classes
defined
within
the
same
cluster
class
and,
as
you
can
see,
since
this
cluster
class
is
a
reference
to
it's,
a
collection
of
references
to
a
lot
of
other
templates.
The
other
templates
that
were
just
referenced
within
the
cluster
class
are
also
defined
within
the
same
file,
so
the
docker
cluster,
so
the
docker
cluster
template
the
kcp
template
the
kvm
control
plane
template
the
docker
machine
templates,
the
bootstrap
templates.
A
All
of
them
are
defined
within
the
same
file,
so
let's
just
first
create
a
management
cluster.
So
I'm
going
to
create
a
kind
cluster
to
use.
As
my
management
cluster,
I
have
a
small
script
that
helps
me,
create
coin
clusters
and
also
load
some
hi
proxy
docker
images
onto
the
management
cluster
to
bypass
some
of
the
docker
limits.
So
let's
just
wait
for
that
to
finish
up,
and
while
we
are
going
through,
we
can
also
see
that
the
cluster
class
also
allows
us
to
define
some
additional
sections.
A
Besides,
just
specifying
what
templates
to
use
example
like
we
can
define,
we
can
use
cluster
class
to
also
define
what
kind
of
labels
should
be
applied
on
what
kind
of
annotations
should
be
applied
and
all
the
clusters
that
use
the
same
cluster
class
will
get
the
same
labels
and
will
get
the
same
annotations
at
that
point.
So
it
also
becomes
easier
for
users
to
like
roll
out
changes
to
multiple
clusters
at
the
same
time,
by
just
making
changes
in
the
cluster
class.
We'll
take
a
look
at
a
real
example
of
how
that's
done
and
yeah.
A
I
have
my
management
cluster
ready,
so,
let's
just
initialize
this
with
the
docker
provider.
I'm
also
going
to
initialize
this
with
the
aws
provider
for
now
and
for
to
do
this,
I'm
going
to
use
a
local
registry
of
the
providers
instead
of
the
ones
that
we
have
and
the
public
github
registries,
because
I
want
to
use
some
of
the
newest
features
that
we
have
so
before.
We
do
that.
Let's
just
take
a
look
at
the
cluster
class
documentation
that
we
have
as
part
of
our
kubernetes
class
api
book.
A
A
So
when
you
initialize
your
cluster
or
if
you
have
already
initialized
requests,
you
can
just
go
ahead
and
change
the
deployment,
but
you
basically
have
to
enable
the
feature
using
the
feature
gate,
so
we're
going
to
do
that
right
now.
So,
since
we
haven't
yet
initialized
our
management
cluster,
let's
go
ahead
and
initialize
the
management
cluster,
with
the
features
enabled
I'm
also
going
to
enable
the
cluster
the
source
set,
so
that
it
just
simplifies
the
process
of
applying
cnns
on
the
workload
classes.
A
A
A
A
While
the
cluster
is
being
initialized,
let's
also
take
a
look
at
the
cluster
object
on
how
it
uses
cluster
class
right
now.
So
I
have
a
docker
cluster
object
at
this
point
right,
so
the
docker
cluster
object
will
look
very
similar.
Most
of
it
doesn't
look
very
similar
to
how
we
had
clustered
objects
defined
before
right
before
the
cluster
class
and
managed
topologies
came
in
the
new
and
exciting
part
is
the
topology
section
within
the
cluster
spec
within
the
topology
section,
we
have
a
reference
to
the
cluster
class
that
we
want
to
use.
A
So,
as
we
just
saw,
we
have
a
cluster
class
called
docker
cluster,
so
we're
just
going
to
reference
that,
and
then
we
have
sections
showing
I
mean
dictating
how
the
cluster
is
supposed
to
look
like.
So
we're
just
going
to
say
we
want
a
cluster
that
uses
the
121.2
version
of
kubernetes,
we're
going
to
create
a
control
plane
with
just
one
replica
in
it
and
we're
going
to
create
two
machine
deployments.
A
So
I
have
a
crs
for
coming
for
client
net.
So
all
the
docker
buses
that
I
am
going
to
create
are
just
going
to
use
the
kindness
just
going
to
use
kindness
as
a
cmi,
so
it's
auto
applied
since
we've
been
through
the
docker
class
docker
cluster
class
definition.
Let's
just
go
ahead
and
apply
that
and
just
see
how
that
operates:
docker
plus
oh
class.
So
now
we
have
the
cluster
class.
A
A
There
are
all
the
underlying
templates
right,
so
we
have
the
cluster
class.
We
have
the
docker
cluster
template.
We
have
the
docker
machine
templates,
the
one
that
will
be
used
by
the
control
planes
and
the
one
that
we
used
by
the
machine
template
machine
deployments.
So
now
that
we
have
a
cluster
class
defined,
let's
just
go
ahead
and
create
a
cluster
that
uses
this
cluster
class.
So
it's
as
simple
as
creating.
A
A
Kcp
object,
machine
deployments
and
the
fun
thing
that
we
have
to
take
a
look
at
is
templates.
So,
as
we
saw
and
as
vince
mentioned
templates
are
now
so
the
the
topology
controller
has
created
copies
of
the
underlying
templates
that
we
specified
that
will
be
used
by
this
particular
cluster.
So
we
have
a
copy
of
the
control
plane
template
that
will
be
used
by
this
docker
cluster.
We
have
copies
of
the
machine,
the
machine
templates
that
will
be
used
for
each
of
the
machine
deployments
and
so
on.
A
So
at
this
point,
modifying
the
template
is
going
to
be
really
easy,
so
you
just
apply
the
changes
in
your
cluster
cluster
spec
or
in
your
cluster
class,
and
cluster
topology
then
takes
care
of
creating
a
new
template,
then
rolling
onto
machine
components
with
the
new
template
and
so
on.
Let's
just
set
up
a
few
watches
to
see
that
things
are
going
well.
Let
me
just
into
my
dev
box
that
we
have.
A
A
A
Yes,
I
am,
as
you
can
see,
the
cluster
is
created
and
it's
creating
the
kcp
object.
It's
ready.
It's
scaling
up
the
machine
deployments
at
this
point,
we're
just
waiting
for
the
nodes
to
be
ready.
We
can
also
observe
the
same
states
using
the
cluster
to
describe
tool
that
we
have
so
cluster
cuttle
describe
cluster.
A
A
A
The
cluster
object
and
everything
is
at
this
point
ready
and
since
we
know
that
the
cluster
object
is
going
to
be
our
single
point
of
contact
and
single
point
of
control,
let's
just
try
to
play
around
with
that
cluster
object
and
create
like
basically
modify
the
topology
of
our
cluster
by
just
modifying
that
one
cluster
object.
So
let's
go
ahead
and
do
that
so,
let's
edit
the
cluster
object
that
we
have.
A
Let's
say
we
want
to
just
scale
up
machine
deployments
right,
so
we
can
scale
up
the
machine
deployments
and
let's
say
I
want
to
also
scale
up
the
controller.
So
that's
simple
as
just
modifying
this
one
cluster
object
and
we
should
be
able
to
see
those
changes
being
rolled
out
right
so
yeah.
The
kcp
object
is
now
at
3
replicas
and
it's
being
scaled
up
and
the
machine
deployment
that
we
just
changed
is
now
at
two
replicas
and
it
is
also
scaling
up.
A
So
if
we
take
a
look
at
cluster,
you
should
be
able
to
see.
Describe
is
scaling
up
the
control
plane
and
is
also
waiting
for
replicas
current
available
one.
So
it's
trying
to
scale
up
the
machine
deployments
as
well,
while
this
finishes
scaling
up.
Let's
just
take
a
look
at
a
cluster
class
example
for
aws
right
since
we
said
that
aws
also
supports
it
right.
B
A
Not
a
lot
of
providers
do
support
cluster
class,
it's
in
its
very
early
stages,
so
providers
are
still
working
towards
adopting
cluster
class,
but
one
provider
that
is
ready
and
it's
only
available
in
the
main
branch
of
aws
is
the
main
branch
is
aws
provided.
So
if
you
look
at
the
aws
cluster
class
again,
it
looks
very
similar
to
the
topper
class
that
we
had
so
again.
We
have
a
section
for
control
plane.
A
We
have
a
section
for
infrastructure
and
we
have
the
section
for
workers,
except
that
the
templates
that
are
referenced
are
at
this
point
different.
So
we
have
the
infrastructure
cluster,
pointing
to
an
aws
cluster
template
and
the
machine
templates
pointing
to,
and
the
machine
templates
pointing
to
the
aws
machine
templates
and
so
on.
A
Yeah,
so
the
machines
that
have
that,
so
the
naming
schema
is
such
that
it's
always
the
cluster
name,
followed
by
the
name
of
the
machine
deployment
followed
by
a
random
name.
So,
as
you
can
see,
we
saw
we
have
the
docker
cluster
is
the
name
of
the
cluster
mdg
name
of
the
machine
deployment,
and
then
we
have
a
random
name
generated
associated
with
it
and
if
you're
talking
about
the
machine
deployments
again,
it's
the
same
rule
that
follows
right.
A
So
we
have
the
cluster
name,
followed
by
the
machine
deployments,
name
that
we
have
defined
in
our
cluster
objects.
So,
as
you
can
see
here,
we
have
defined
md0
md1.
So
that's
name
of
the
machine
deployment
that
we
have
followed
by
random
object,
and
this
is
so
that
we
can
roll
out
new
machine
deployments
if
we
have.
B
It's
gonna
be
like
so
easy
like
compared
to
what
it
was
before,
and
the
other
thing
that
we
have
here
too,
is
version
right,
and
we
talked
about
how,
for
the
upgrade,
how
easy
to
use
to
twist
to
do
an
upgrade
today
with
cluster
class
and
manage
topologies,
where
you
just
can
set
the
version
in
there
and
it
will
roll
out
safely.
It
will
run
the
control
plane
first
and
then
you
will
do
each
worker
nodes
machine
deployment
one
by
one.
A
And
right
now,
the
mechanism
that
we
have
in
cluster
topology
controller
is
like
a
very
like
safe
mechanism.
So
what
I
mean
by
that
is
it
upgrades
only
one
component
at
a
time
to
be
sure
that
the
upgrade
goes
smoothly,
so
it
upgrades
the
control
upgrades
the
control
plane.
First,
wait
for
it
to
make
it
all
like
stable
and
then
go
ahead.
It
goes
ahead
and
upgrades
the
machine
deployments
again,
one
at
a
time.
A
So
if
you
have
like
two
machine
deployments
like
in
this
example,
it
will
upgrade
the
first
national
department
to
the
newest
version.
Only
after
it
is
stable
will
it
go
ahead
and
upgrade
the
second
vision
deployment
again,
we'll
take
a
look
at
that,
maybe
right
now,
if
this
is
done
yep,
so
we
were
able
to
scale
up
our
control,
plane
and
scale
up
our
machine
domains
just
by
updating
the
cluster
object.
So
cluster
object.
Truly.
B
So
carlos
is
pointing
out
like
crossblending
chat,
so
just
first
of
all,
like
you
said,
like
I
was
using
sims
here.
This
is
one
of
the
shift
machine
set.
I'm
not
aware
like
what
openshift
is
doing.
I
do
believe
that,
like
they
are,
they
were
using
machine
sets
from
older
versions,
but
machine
set
is
one
layer
below
of
a
machine
deployment,
so
machine
deployment
will
actually
create
machine
sets
and
machines
that
will
roll
those
out.
I
don't
I'm
not
sure
like
about
the
whole,
the
specific
integration
of
those
apis.
B
I
know
that
there
are
important
cluster
api
crds
for
that,
but
and
then
crossplane,
so
cluster
class
was
actually
like
inspired
the
crossplane,
like
kind
of
crd,
within
a
crd
definition
where
you
have
like
that
meta
crd,
but
we
have
we
wanted
to
collaborate
like
on
the
infrastructure
parts
with
crossplane
over
time,
so
those
stocks
are
still
ongoing.
It's
really
in
early
stages,
where,
like
you,
can
just
delegate
to
crossplane
to
just
like
a
do
the
managing
of
the
infrastructure
and
then
just
tell
cluster
api.
B
A
Yes,
so,
while
before
we
do
upgrade,
I
also
do
want
to
create
an
aws
cluster,
because
that
takes
a
while.
So
we
can
just
keep
that
in
the
background
and
then
up
try
to
upgrade
the
rocket
cluster
so
again.
Creating
the
aws
cluster
is
as
simple
as
just
creating
the
cluster
class
first
playing
the
class.
A
A
Being
provisioned
right
now,
so
this
is
okay.
While
that's
happening.
Yes,
let's
go
ahead
and
just
upgrade
the
version
of
the
docker
cluster
from
the
121.2
and
then
see
how
it
actually
rolls
out
the
entire
upgrade
process.
So
let's
take
a
look
at
that,
so
I'm
going
to
edit
the
cluster
object
and,
let's
see
so
all
I
need
to
do
at
this
point
to
perform
an
upgrade
is
just
change
the
version.
A
So
I'm
going
to
jump
to
the
122.0
version,
let's
say
right
so
and
that
state,
so
that's
all
the
ux
that
the
user
has
to
do
to
take
care
of
an
upgrade
and
now
clustering
api
along
with
cluster
class
and
managed
topologies
will
take
care
of
bump
it
up.
So,
as
you
can
see,
the
the
kcp,
the
control
plane
object
of
docker
cluster
picked
up
the
new
version.
It's
waiting
for
it
to
finish
up
the
complete
upgrade.
A
A
This
so
let's
just
change
it
to
so.
The
condition
that
we
want
to
take
a
look
at
is
topology
reconcile
right,
so
topology
reconciled
is
a
condition
that
reflects
if
the
topology
that
is
specified
in
the
spec
has
been
translated
down
to
the
spec
of
the
underlying
objects.
Right,
so
is
the
topology
updated
to
all
the
underlying
objects,
like
the
kcp
object,
the
machine
department
objects
and
so
on
and
right
now
it
is
in
the
pending
state,
because,
as
I
mentioned,
the
upgrade
process
takes
care
of
upgrading
only
one
component
at
a
time.
A
So
this
condition
is
a
great
way
of
visualizing
how
the
upgrade
process
is
going
on
and
of
course,
you
can
always
rely
on
just
like
using
the
kcp
objects
underlying
kcp
objects
and
the
machine
deployment
objects
to
see
what
the
status
of
the
what
the
status
of
the
upgrade
process
is
looking
like.
So
right
now
we
can
see
that
the
kcp
object
is
still
trying
to
finish
up
the
upgrade,
so
only
one
of
them
is
updated
and
it's
trying
to
roll
out
new
machines
and
then
delete
the
old
machines
at
the
old
version.
A
So,
as
you
can
see
the
docker
cluster,
so
we
have
a
new
version,
so
we
have
machine
with
the
new
version
provision.
So
once
this
is
ready,
it
will
start
scaling
down
the
old
versions.
As
you
can
see
here
and
once
that
happens,
it
will
start
moving
on
to
the
newest
scale,
rolling
out
all
the
three
replicas
of
the
complaint.
Since
we
have
a
three
replica
control
plane
and
once
this
process
completely
finishes
basically
kcp's
spec
and
status
match.
That
is
when
kcp
is
completely
considered
to
be
ready
at
the
newest
version.
A
The
process
will
automatically
start
moving
on
to
the
machine
deployments
and
the
machine
deployments
are
actually
updated
in
the
same
order
that
they
are
mentioned
in
the
topology
spec.
So
this
gives
us
two
advantages.
One.
The
order
in
which
the
machine
deployments
are
upgraded
is
predictable,
is
definable
and
two
users
can
choose
to
rearrange
the
machine
deployments
if
they
have
preference
of
updating
one
machine
deployment
to
the
newer
version
before
the
other
right.
So
the
machine
apply.
A
The
control
plane
object
is
going
to
be
upgraded
first,
the
newest
version,
and
while
that's
happened
and
once
that
is
done,
the
machine
deployments
will
be
upgraded
one
at
a
time.
Okay,
there
is
another
question:
eks
anywhere
is
using
capi,
but
not
sure.
If
using
this
new
feature,
I
don't
think
it
is
this
new
cluster
class
feature
yet
because
the
cluster
class
feature
is
still
being
built
and
is
being
behind
and
is
behind
the
feature
gate.
A
At
this
point,
the
newest
release
of
crossfi,
the
v102
version,
is
still
very,
has
very
nascent
support
for
across
the
api.
It
doesn't
have
the
full
fully
built
features
within
cluster
for
cluster
class
within
cross
api,
so
I
think
it
might
be
a
while,
before
it
switches
over
to
using
the
before
providers,
start
switching
over
to
start
using
cluster
class
as
the
default
docker
class
is
for
kind
right.
B
A
Class
is
the
cluster
class
that
I'm
using
to
be
able
to
spin
up
docker
clusters,
so
it
is
going
to
use
the
docker
provider
that
plus
api
has
so
class.
Api
has
multiple
providers,
so
it
has
like
the
aws
provider,
the
vca
provider,
docker
provider
and
so
on.
So
the
docker
class
that
I
have
is
using
the
docker
provider
that
I
have
installed
on
my
management
cluster.
I
hope
that
answers
your
question.
Carlos.
A
A
Not
related
to
kind-
I
think
I
saw
kindness
yeah,
so
I
am
kindnet
is
the
one
that
I'm
using
to
kinetic
is
the
cn
that
I'm
using
for
as
a
cni
for
the
docker
clusters
and
I'm
using
calico
as
the
cmi
for
the
aws
clusters,
and
now
that
I've
applied
the
cni
applied
the
cluster,
the
source
set,
which
automatically
will
go
ahead
and
apply
the
cni
on
the
target
cluster,
which
is
the
aws
cluster.
You
can
see
that
the
control
plane
for
the
aws
cluster
is
now
ready.
A
A
Cool
we're
just
waiting
for
the
last
node
on
the
control
plane
of
docker
to
finish
upgrading
to
and
once
that
kcp
object,
upgrades
we'll
observe
the
automation
requirements.
Oh
great,
nice
timing,
so
the
docker
cluster
finished
the
docker
clusters,
kcp
finished
upgrading
from
120
to
121
121.2
to
122.0
completely,
and
we
can
see
that
the
first
machine
department
of
the
docker
cluster
picked
up
the
new
version.
A
We
can
see
that
the
kubernetes
version
is
122
0
and
let's
go
back
and
take
a
look
at
the
conditions,
and
you
can
see
that
the
condition
also
reflects
the
same
information
right.
The
machine
deployment
the
say
md1
is
waiting
is
still
waiting
on
picking
up
the
122.0.
It's
still
on
hold,
because
the
machine
deployment
md
0
is
in
the
process
of
rolling
out
right.
Only
after
the
machine
deployment,
md
0
finishes
its
upgrade
to
the
newest
version.
Will
we
be
able
to
create?
Will
the
second
machine
deployment
md1
pick
up
the
new
version?
A
We
have
a
question:
how
is
the
aws
vpc
created?
You
have
to
create?
You
have
to
create
it
beforehand.
I
think
it
is
created
as
part
of
the
aws
cluster
object.
So,
as
you
can
see
when,
when
we
created
the
data
plus
cluster,
when
we
created
the
cluster
object,
that
is
of
type
aws,
it
underline,
creates
an
aws
cluster
object.
A
A
And
it
creates
so
when
we
create
the
aws
cluster,
it
creates
the
load
balancer
for
us,
it
creates
vpc
for
us
and
it
creates
all
the
items
needed
to
be
able
to
create
the
full
aws
cluster.
It
goes
ahead
and
that
point
creates
the
goes
again
at
that
point,
creates
the
ec2
instances
that
will
act
as
nodes
for
our
cluster
and
so
on.
B
B
B
So
at
the
time
like
we
just
created
this,
this
whole
new
thing,
but
we'll
we'll
see
how
it
goes
like
you
know
going
forward
and
we'll
definitely
make
sure
that
I'm
going
through
it
a
little
bit
more
if
the
magic
cluster
crashed.
Can
we
create
the
kind
client
cluster
to
continue,
manage
the
docker
cluster
and
the
best
cluster
in
your
demo?
B
Maybe
so,
like
you,
you
want,
if
you
just
delete
and
you
lose
all
the
data
you
would
not.
You
would
not
be
able
to
like
recover
like
any
of
that,
but
if
you
do
have
backups
you
can
restore
those
those
backups
and
costracado
already
has
a
way
to
actually
like,
like
kind
of
like
pause.
The
whole
cluster
put
everything
in
on
files.
So
there's
like
a
backup
underscore
mechanics
in
there
and
then
you
can
restore
that
as
well.
B
The
other
thing
that
closer
cutter
can
do
is
to
move
management
clause.
So
let's
say
that
you
have
a
management
class
that
you
know
when
you
want
to
put
out
a
service.
For
example,
you
want
to
move
all
of
your
manager
closer
to
another
one.
You
could
easily
move
that
with
cluster
cuddle.
It's
like
a
one-time
operation
and
you
know
like
we
would
expect
an
operator
to
do
that,
because
it's
kind
of
one-off
and
it's
dangerous
but
yeah
definitely
have
backups.
If
you're
doing
this
in
production.
B
A
A
A
Yeah,
it
basically
throws
an
error
that
it
is
invalid
because
it
we
currently
prevent
from
downgrading
using
the
cluster
cluster,
because
the
best
way
to
do
I,
I
think
the
the
right
way
to
do
downgrading
at
this
point
is
to
like
create
a
backup
of
the
version
that
you
already
work
at
at
that
point
and
then
do
an
upgrade.
If
not,
if
not
just
restore
back
to
the
backup
and
that's
where
valero
comes
in.
A
B
A
A
A
A
Tooling,
around
cluster
class
right
so
right
now
we
have
a
lot
of
tooling
around
across
the
class.
That's
so
cluster
api
itself
comes
with
a
lot
of
tooling
right
now
so
example.
Cluster
control
is
the
cli
that
we've
been
using
to
like
show
conditions
and
initialize
and
perform
class
api
upgrades
and
so
on.
So
all
of
these
tooling
has
been
upgraded
to
also
support
cluster
class.
A
So
one
of
the
key
things
that
cluster
cuttle
enables
is
users
to
do
quick
start
like
quickly
jump
into
and
create
cluster
classes,
create
clusters
from
scratch,
with
just
a
kind
class
with
just
a
booster
cluster
and
so
on,
and
let's
just
go
over
that.
So
let's
take
a
look
at
how
quickstart
looks
like
right
now
and
then
we
can
see
how
that
would
look
like
with
cluster
class
in
play.
So
this
is
the
documentation
that
we
have
for
clock,
ai
and
the
quick
start
flow.
A
A
A
So
cluster
catal
generate
cluster
helps
us
create
the
clustered
yamls
that
we've
been
seeing
till
now.
So
the
cluster
cloud,
the
glossary
ammo
that
needs
to
be
applied
onto
the
clusters
to
get
a
full
cluster
and
the
cluster
control
generate
command,
has
now
been
upgraded
to
be
also
able
to
support
generating
cluster
yamas
that
use
cluster
classes.
So,
let's
take
a
look
at
a
standard
example
of
how
a
cluster
looks
like
when
we
use
the
classical
generate
commands
output
looks
like
when
we
don't
use
cluster
classes
right.
A
A
B
A
A
So
the
docker,
simple
cluster.yaml
looks
the
one
that
we
are
all
familiar
with
it
create
it
has
a
cluster
of
docker
cluster
object,
the
machine
number.
It's
basically
all
the
objects
in
the
hierarchy
that
we
need
to
create
one
cluster.
So
this
is
a
standard
way
of
creating
clusters
that
we
had
till
now,
and
this
is
how
the
and
since
the
development
flavor
that
we
used
uses
the
standard
way
it
turns
out
to
come
out.
A
The
output
looks
very
similar
to
that
now,
let's
use
the
flavor
that
uses
cluster
classes
instead,
so
we
have
a
cluster
topology
that
uses
the
docker
simple
cluster.
Oh,
the
name
is
confusing,
but
anyway,
so
we
have
a
cluster
class
called
docker
simple,
so
it's
references
across
the
class
called
docker
simple.
But
the
point
to
note
is:
it
is
not
that
particular
cluster
class
is
not
available
on
the
cluster
at
this
on
the
management
cluster
at
this
moment.
So
let's
see
how
that
works
out.
A
A
It
makes
it
goes
ahead
and
checks
within
the
existing
management
cluster
that
we
are
operating
against
and
sees
if
there
are
any
cluster
classes
that
need
to
be
installed
that
are
not
already
installed
if
there
are
any
bits
that
need
to
be
installed
and
not
already
installed
and
so
on.
So
it
is
warning
us
that
a
template
with
this
name,
the
docker
machine,
the
docker
worker
template-
is
already
available
on
the
cluster.
And
if
we
try
to
apply
this
new
cluster
it
might
it
might
conflict
with
it.
So
it's
it's.
A
There
are
safeguards
in
place
for
us
to
be
able
to
avoid
any
foot
guns
so
that
like
helps
us
to
make
sure
that
we
don't
modify
the
cluster
class
or
modify
the
underlying
templates
in
the
cluster
class
by
any
with
by
randomly
applying
another
template
and
then
causing
ripple
effects,
because
changing
cluster
classes
can
have
ripple
effects
because
multiple
clusters
can
be
using
the
same
cluster
class.
So
if
you
change
anything
on
the
cluster
class,
all
the
classes
will
at
that
point
get
affected.
A
So
it's
a
very
powerful
tool
sim,
but
at
the
same
time
it's
also
very
dang.
It's
also
it's
a
potential
foot
gun
that
the
users
have
to
be
very
cautious
while
using,
and
one
of
the
features
that
we
put
in
place
is
something
called
rebase.
We
can
talk
about
that
a
little
bit,
which
is
basically,
if
you
want
to
roll
out
if
you
want
to
be
able
to
change
the
cluster
class,
but
you
are,
but
you
want
to
be
safe
and
you
don't
want
to
affect
all
the
underlying
clusters.
A
The
idea
behind
the
ebase
is
basically
create
a
duplicate
of
the
cluster
class
and
then
just
modify
that
one
cluster
to
point
to
a
different
cluster
class.
So
right
now
we
have
our
docker
cluster,
pointing
to
the
docker
class.
So
if
we
create
another
cluster
class
with
say
let
some
of
the
templates
modified
or
some
other
worker
worker
deployments,
worker
deployment
classes
modified
and
so
on.
A
We
can
just
rebase
the
class
to
point
to
a
new
one
and
the
topology
reconciler
will
try
to
restructure
or
reconcile
the
existing
cluster
to
match
the
underlying
cluster
class,
that
it
was
that
it
has
now
been
updated
to
point
to.
This
is
also
something
that
needs
to
be
done
carefully
because
again,
there
are.
There
are
safety
checks
in
place,
for
example,
there
is,
there
are
something
called
compatibility
rules
that
both
the
clusters
have
to
both
the
cluster
classes
have
to
match.
A
B
A
A
A
Rocker
topology,
so
the
docker
simple
example
that
we
generated
using
cluster
cutter
generate
plus
the
command
that
doesn't
use
a
deployment.
Flavor
that
has
that
is
using
cluster
class,
basically
creates
all
the
hierarchy,
like
all
the
objects
that
are
needed
in
the
hierarchy,
to
create
the
cluster
so
plus
the
docker
cluster
and
so
on,
but
when
it
comes
to
but
comes
to,
let's
say
the
cluster
class
associated
with
it
right
when
we
are
using
a
flavor
that
uses
cluster
class
right.
So
we
have
the
cluster
object
in
it.
A
But
since
this
cluster
at
this
point,
reference
is
a
cluster
class,
that's
not
already
installed
or
not
already
available
on
the
cluster.
It
basically
adds
the
entire
definition
of
the
cluster
class
and
all
of
the
templates
into
the
yaml
right.
So
at
that
point
the
the
flow
is
just
going
to
be
like
topology.
We
can
just
apply
the
cml,
it
creates
the
cluster
class,
it
creates
all
the
associated
templates
and
it
also
creates
the
cluster.
Now,
let's
try
to
repeat
the
same
thing:
let's
try
to
we
create
another,
create
another
cluster
called.
A
At
this
point,
you
can
see
that
the
output
just
has
the
cluster
object,
so
the
ux
of
creating
the
second
cluster
is
as
simple
as
just
basically
creating
the
cluster
object,
because
the
cluster
cuttle
command
is
smart
enough
to
figure
out
that
the
underlying
cluster
class
that
it
references,
is
already
installed
on
the
management
cluster.
So
it
doesn't
have
to
add
that
to
the
output,
template
and
all
it
needs
is
the
cluster
object
so
from
here
on
as
long
as
you're
using
a
cluster
class,
that's
already
installed,
or
that's
already
available
on
the
final
cluster.
A
How
the
mo
operation
works
right
now.
Is
it
pauses
all
the
clusters
associated
and
then
performs
a
move
from
one
management
cluster
to
the
other?
So
let's
just
wait
for
this
cluster
to
also
reconcile
completely
before
we
perform
the
move
operation.
In
the
meantime,
let's
see
if
there
are
any
questions
in
the
chat
that
you
can
answer.
A
A
B
Not
only
the
cluster
object
becomes
the
single
point,
but
it
also
becomes
like
a
more
useful
object.
It
ties
everything
together,
but
also
defines
and
informs
like
what
the
topology
of
that
cluster
should
look
like,
and
so
I'm
excited
to
see
like
where
we
go
from
here
like
for
you
know,
as
we
go
into
2022.
A
B
A
Have
I
have
created
a
second
kind
cluster?
That's
going
to
act
as
our
management
target
management
cluster
that
we
want
to
move
to
and
before
we
perform
the
move
operation
we
also
have
to
initialize
the
second
cluster,
with
the
same
set
of
providers
that
we
have
on
our
first
cluster.
So
let's
do
that.
A
A
A
A
A
Okay,
it's
okay,
so
clusters,
maybe
if
it's
on
the
first
one,
so
cluster
cuttle
move
to
cube
config
second
cube,
so
it
is
performing
the
operation
and
you
can
see
it
is
moving.
The
three
cluster
objects
that
we
have
and
it's
moving
the
two
cluster
class
objects
that
we
have
and
that's
it.
We
just
finished
our
move.
So
if
we
just
switch,
if
we
do
clusters
on
the
original
cluster,
we'll
have
nothing
at
this
point.
A
There
are
some
questions.
Can
you
show
the
access
control
service
accounts
for
those
crds
in
your
kind
of
kind,
so
that
this
so
that
some
people
can
read
but
not
update
them
access
control?
So
you
want
to
see
the
outback
policy,
so
is
that
right?
You
should
access
control
service
accounts.
Here
this.
B
A
A
A
Just
to
okay,
so
that's
cluster
class
and
managed
topologies.
I
think
we've
gone
through
most
of
the
topics
that
we
wanted
to
go
over
and
highlighted
some
of
the
topics,
so
just
to
reiterate
on
what
the
new
cluster
class
feature
and
what
managed
topologies
mean
is
so
cluster
class
and
managed
topologies.
A
A
A
A
The
aws
class
that
we
have
used
right
now
relies
on
a
lot
of
defaults
like,
for
example,
it
defaults
to
the
instance,
type
of
dp
dot
large
and
it
defaults
to
this.
It's
key
of
tgik.
I've
already
had
this
sh
key
and
so
on.
So
it
relies
on
a
few
defaults
within
the
the
templates
associated
with
it,
and
it
defaults
to
either
it's
in
the
region
and
so
on.
A
So
what
if
we
want
the
cluster
to
be
able
to
also
configure
these
values
right,
let's
say
the
cluster
class
doesn't
define
the
region
that
doesn't
define
the
associated
sh
key.
But
let's
say
we
also
on
the
cluster
to
define
them
right.
So,
in
those
cases
we
have
the
there
is
this
whole
idea
of
a
patch
engine.
B
A
So
on,
but
if
you
look
at
the
aws
cluster
template,
it
doesn't
have
an
instance
type
value
already
defined
in
it
right,
so
this
has
to
be
replaced,
and
this
can
be
replaced
with
the
value
that
we
specify
and
what
that
looks
like
is
within
the
clusters.
We
we're
going
to
have
this
new
section
called
matches
which
defines
a
list
of
patch
operations,
basically
json
patch
operations
that
can
be
performed
on
top
of
the
template
and
a
cluster
that
is
using
a
cluster
class
that
define
patches
is
going
to
look
like.
A
This
cluster,
this
and
if
you
look
at
the
cluster
that
is
using
a
cluster
class
with
patches,
it's
going
to
look
like
this,
where
it
specifies
to
the
cluster
class
that
has
more
advanced
configurability,
and
then
it
specifies
a
bunch
of
variables
that
it
wants
to
replace.
So
it
basically
says:
okay,
the
s6
key
name
is
tgik,
so
the
machine
type
is
d3,
dot,
large
and
so
on.
A
So
with
this,
the
cluster
class
becomes
even
more
configurable,
even
more
extensible
and
we'll
talk
more
about
patches
in
a
future
tgik
episode,
because
patches
is
a
full
thing
on
itself
and
there
are
various
kinds
of
patches
that
really
really
take
cluster
classes
to
the
next
level
in
terms
of
configurability
and
extensibility.
So
we'll
do
another
deep
dive
into
cluster
class
and
the
patch
engine
associated
with
cluster
class
into
in
another
tgik
episode.
A
Another
thing
that
we
would
want
to
take
a
look
at
the
next
thing
is
a
machine
tech
support
being
built
into
cluster
class.
So
right
now,
cluster
api
does
come
with
machine
health
check
supports
and
the
cluster
class
and
the
clusters
that
we've
built
during
this
demo
can
be
integrated
with
machine
health
checks.
A
Basically,
you
need
to
define
a
machine
filter
configuration
with
the
right
labels
to
be
able
to
configure
machine
learning
on
the
machine
diplomas
that
you
have,
but
there
is
this
proposal
about
integrating
machine
health
6
directly
into
the
cluster
class
so
that
it
all
becomes
one
cohesive
piece
right.
So,
while
defining
the
cluster,
you
also
define
the
machine
health
check
criteria
for
the
cluster
and
for
the
associated
machines
and
so
on.
So
I'm
going
to
link
a
pull
request.
A
A
I
think
we've
covered
all
the
points
that
we
wanted
to
talk
about.
The
demos
also
showed
how
cluster
api,
along
with
cluster
classes
massive
lead,
simplifies
the
ux
of
being
able
to
create
clusters
using
just
one
object
and
being
able
to
operate
on
the
cluster
object,
which
is
by
handling
and
editing
just
one
object,
which
is
the
cluster
object
and
how
the
future
of
the
cluster
class
project
looks
like
before
we
close
out
pins.
Did
you
have
any
final
thoughts
that
you
wanted
to
share.
B
So,
like
you,
just
put
the
variable
in
there
and
the
cluster
will
reconcile
like
everything
in
the
future,
like
what
we
will
do
is
probably
like
also
enable,
like
other
ways,
to
define
these
variables
and
patches,
but
also
like
improve
the
visibility
of
it
so
like
when
you
change
a
variable
like
you
probably
want
to
know
what
happens
in
the
cluster
right
like.
Is
this
gonna
roll
out
everything?
This
is
only
gonna
relent
like
partially
and
like
I,
I
do
believe.
B
A
A
Sure
so,
regarding
driver,
so
as
as
I
was
mentioning
so
when
you
change,
let's
say
the
cluster
object
or
the
cluster
class
object
associated
since
it
generally
has
a
ripple
effects,
because
changing
the
cluster
topology,
let's
say,
goes
ahead
and
updates
the
machine
deployments
and
so
on
right
or
goes
ahead
and
updates
the
kcp
object
and
so
on.
So
the
whole
idea
behind
trident
is
within
the
class
within
cluster
cuttle.
A
A
Is
this
change
compatible?
Is
this
change
not
compatible?
Will
the
change
be
rejected?
Will
the
change
be
accessed
and
so
on?
Similarly,
we're
going
to
have
driving
capability
of
being
able
to
edit
modify
cluster
on
making
changes
on
cluster
objects
and
then
see
how
the
output
is
going
to
look
like
basically,
change
see
how
the
machine
deployments
will
get
updated,
see
how
the
templates
will
get
rolled
out
and
so
on.
A
That
feature
is
being
built
in
so
stay
tuned
to
see
how
that
turns
out,
and
while
we
are
on
the
topic
of
cluster
cuttle,
as
we
saw
cluster
cuttle
has
the
ability
to
also
operate
with
operate
with
cluster
class
based
cluster
templates
right.
So
we've
seen
how,
when
we
point
to
a
cluster
that
uses
a
cluster
class,
it
goes
ahead
and
brings
in
the
cluster
class
and
adds
it
to
the
template.
If
it's
not
already
installed
and
skips
it
if
it
is
installed
and
so
on.
A
So
this
is
largely
dependent
on
the
providers,
because
the
providers
are
the
ones
who
ship
the
template,
yamls
and
also
the
cluster
class
definitions,
so
for
all
the
providers
out
there.
So
we
have
updated
the
cluster
to
provide
a
contract
on
how
you
can
use
or
how
we
can
opt
in
to
also
provide
templates
that
cluster
templates
that
rely
on
cluster
classes
and
cluster
topology.
A
Yeah,
okay,
awesome
great,
so
I
think
we've
covered
all
the
points
that
we
wanted
to
do.
I
wanted
to
talk
about.
We've
went
through
cluster
api
v1
release,
we've
done
an
overview
of
cluster
class,
we've
seen
how
cluster
class
works
with
clusters
and
how
the
cluster
structure
changed
because
of
the
introduction
of
the
new
managed,
topologies
and
cluster
classes.
Hope
everyone
gives
it
a
try
and
sees
how
it
and
then
gives
us
feedback
on
the
overall
feature.
A
You
can
find
the
cappy
team
on
the
usual
channel,
so
the
slack
channel
the
github
projects.
We
can
open
issues
and
discussion
threads
there
and
you
can
also
reach
out
to
us
in
kubernetes
slack.
I
think
the
channel
is
called
cluster
hyphen
api
and
you
can
find
us
there.
So
we
are
all
you
get
to
get
feedback
on
the
project
and
we
are
excited
to
see
what
you're
going
to
what
everyone's
going
to
do
with
cluster
class.
This
new
feature
in
cluster
api.