►
Description
No description was provided for this meeting.
If this is YOUR meeting, an easy way to fix this is to add a description to your video, wherever mtngs.io found it (probably YouTube).
A
B
Well,
I
just
sorted
the
getting
to
documentation
and
specification
so
and
also,
and
seeing
how
likely
is
to
implement
the
dynamic
creation
of
notice
in
kind
upper.
Only
four
we
have
seen
the
go
so
far.
It
will
require
some
refactoring
of
the
code,
but
the
pieces
out
there,
mostly
because
kinda
done
a
very
nice
work
on
creating
a
framework
for
executing
action
of
notes.
I
mean
it's
like
a
very
structured
way
of
creating.
It
is
not
a
bunch
of
code.
This
is
something
which
is
splitting
actions
and
you
can
schedule
action
notice.
It's
very
nice.
B
How
can
has
stick
to
that
code,
so
I'm,
confident
that
that
part
I
would
eventually
be
easy
to
implement.
What
I'm
now
trying
to
figure
out
is
how
to
start
I
mean
what
will
be
the
shortest
path
to
creating
a
initial
I
would
say
only
it's
got
four
code
for
for
a
cross.
The
provider
I
mean
is
what
what
what
should
I
do.
There
is
any
sample
or
any
basic
stuff,
because
I
see
just
this
morning,
someone
on
the
slack
channel
that
mentioned
that
he's
implementing
a
bare-metal
provider
for
closer
API.
B
It
was
my
saying:
I'm,
just
startin
I
create
a
project.
I
make
like
an
initial
could
meet.
I
will
take
a
look
at
that
because
they
were
probably
is
to
start
with
something
which
is
like
very
basic
just
to
struck
the
common
part.
Well,
I
was
wondering,
do
you
have
any
template
or
you
know,
because
I
suppose
it
is
a
lot
of
stuff
which
is
common
because
it
basically
all
the
types
you
need
to
use
for
the
for
the
controller
or
stuff
like
that.
Well,.
B
C
If
you,
if
you
really
want
to
use
parts
of
the
the
cost
repair
project,
I
mean
with
any
clears
control
project
could
have
API
implementation
that
is
been
working.
We
didn't
find
it
very
useful
to
actually
use
the
common
parts,
because
all
of
that
was
quite
different
from
what
we
needed.
So
we
we
have
foot
buster
API
of.
C
C
Pretty
much
from
scratch,
so
the
thing
is,
we
already
had
a
CLI
and
we
wanted
CLI
a
config
file
support,
so
it
be
able
to
create
clusters
based
of
config
file
and
then
they
dilute
based
on
config
file,
etc.
So
we
wanted
that
and
we
didn't
want
the
controller
to
begin
with.
I
just
wanted
to
fit
config
the.
C
Config
files
into
a
CLI
into
a
chaos
control,
and
we
we
found
pretty
much
most
of
the
cluster
API
repositories
bits
like
all
the
all
the
other
code
that
is
in
the
cluster
across
three
was
hard
to
fit
into
this
model,
because
it
kind
of
does
pretty
different
things.
So,
for
the
time
being
where
we
are
working
with
our
own
implementation,
but.
B
Either
types
because
the
types
are
not
I
mean
so
far.
Have
you
seen
that
for
instant
all
these
API
is
keema
all
the
goal.
Types
are
not
being
sport
like
a
Co
package
that
can
install
and
reuse
was
like
I
need
to
copy
that
code.
They
might
throw
it
right.
He
said
this
is
correct.
Yeah,
that's
it's
a
common
way
to
do.
A
Yes,
so
for
I
think
so
when
cluster
API
moved
to
the
CR
DS,
it
got
me
based
on
to
using
Q
builder
and
so
I
think
most
the
deployers
have
moved
to
that.
Where
can't
you
do
some
stuff
in
AWS
the
add
basil
hooks
to
automate
that
cocking
process,
so
you
don't
actually
have
to
do
it
directly.
You
don't
have
to
directly
copy
paste
again.
A
So
there's
a
bit
of
a
chicken
and
egg
problem
there.
There
is
an
intent
to
do
like
a
one-shot
process,
which
will
behave
a
lot
more
like
what
we've
works
has
been
doing
in
eks
cuttle
and
hasn't
really
started
yet,
but
then
probably,
which
would
be.
We
would
be
able
to
leverage
the
controller
code
call
directly
into
them,
for
example,
from
a
command
line
here
and
the.
C
C
C
You
would
be
able
to
employ
that
you'd
be
able
to
use
the
CLI
to
the
first
cluster
and
then
make
that
cluster
management
Questor
of
your
many
other
clusters
right
so
you'd,
be
able
to
use
config
file
to
to
create
a
management
cluster,
and
then
management
clusters
manage
other
clusters
and
you'd
be
able
to
update
that
to
be
plus
using
this
July,
potentially
even
with
those
objects
that
manage
the
cluster
itself,
like
self-referential
type
subject
into
into
the
cluster
itself.
So
that's
to
be
figured
out.
C
B
We
were
astir
using
kind
for
testing,
because
it's
a
little
really
like
why
this
is
perfect,
for
continuous
integration
is
quite
fast
just
yesterday
this
morning,
I
was
just
making
just
this
and
that
created
and
elated
cluster
like
well
every
two
minutes
or
something
like
that.
It's
quite
fast,
so
we
said
no
that
makes
sense
and
not
so
there's
an
additional
integrates
for
all.
They
use
Cuba
for
bootstrapping
the
cluster.
Basically,
what
they
do
is
they
be
drowned
out,
and
we
also
do
that,
so
we
also
have
to
run
into
them.
B
So
it's
like
the
architecture
and
the
pose
was
really
appealing
and
then
in
the
last
couple
we
they
have
been
like
crazy,
like
crazy,
adding
stuff,
but
they
create
they.
Something
to
you,
the
multi
node
cluster
me
one
master,
no,
those
multiple
workers,
but
now
there
are
also
produced
multi
master
and
they're
moving
very
fast.
So
now
they
are
like
real
capable
of
creating
complex
clusters,
and
four
authors
is
important
because
it
allows
us
to
test
course
offering
multiple
cluster
by
scenarios.
B
They
already
have
Graham
internally.
So
for
us,
it's
like
it
looks
like
a
good
combination
of
abusing
time
for
development
of
our
own
cluster
management.
I,
don't
see
the
chicken
and
egg,
and
it
says
that,
as
you
said,
you
first
create
one
cluster
that
can
be
a
single
cluster.
A
single
master
and
then
you
would
drop
the
other
cluster
from
this,
so
you're,
probably
not
running
you're,
not
managing
it
master,
most
early
seed
cluster
using
the
controller,
but
you
can
use
that
controller
for
creating
others
that
does
model
the
way
we
plan
to
work.
B
C
So
it's
just
like
you
know,
you
know
it's
like
it
is
one
of
the
user,
whether
your
target
user
is
happy
with
the
idea
of
creating
a
cluster
for
some
temporary
use
or
having
some
kind
of
parent
cluster
right
so
because
for
for
the
case
of
achæans
control,
obviously
there's,
but
is
that
that
would
be.
That
would
be
like
a
negative
feature
right
people
wouldn't
be
happy
to
to
have
to
like.
If
you
want
to
say
hey
before
you
can
create
a
cluster
Nikias,
you
need
to
run
some
little
local
cluster.
C
So
if
you're,
if
you're
happy
with
you
know,
and
if
your
users
are
happy
with
having
some
kind
of
set
central
management
control
plane,
which
everything
depends
on
that's,
okay,
you
know
or
if
you
can
rely
on
the
fact
that
they
all
run
Linux
and
you
can
run
docker.
That's
totally
fine,
too
right.
Yeah.
B
B
This
yeah,
our
customer
can
handle
that
easily
because
they
understand
that
you
need
to
have
a
reliable
way
of
point
of
management
and
what
we
are
working
is
in
having
high
availability
of
all
this
component,
because
obviously
you
cross
the
tender
be
more
likely
that
the
control
plane
is
so,
but
yes,
I
mean
for
us.
That's
not
the
problem.
An
issue
is
how
it
works.
Now
our
customers
are
are
perfectly
comfortable
with
that.
B
What
is
true
is
that
now
the
at
the
mean
know
this:
it's
like
a
separate
entity
which
is
not
really
not
even
our
kubernetes
cluster
itself.
So
one
of
the
objective
is
probably
really
use
it
as
a
cumulative
clusters
or
components
are
actually
operators
running
there.
We
could
be
reading
a
copywriter
based
architecture,
because
we
thing
is
easier.
Whoever
started
doing
some
development
life,
for
instance,
automatically
upgraded
on
deploying
the
certificate.
B
If
you
want
to
use
your
own
registry
for
the
role
in
the
images
for
docker
and
you
need
a
certificate,
we
create
an
operation
automatically
deployed
or
refresh
that,
and
it's
that
see
mean
once
you
get
it
lady
is
it
make
sense
a
lot
of
sense.
So
probably
our
future
architecture
will
be
a
real
kubernetes
cluster
managing
holdest,
often
one
or
more
crosses
more
for
all,
set
more
interesting,
the
multi
cluster.
C
Basically,
yeah,
that's
understood,
I,
just
sort
of
wanted
to
give
you
one
use
case
just
to
be
clear
what
the
kind
of
things
I'm
thinking
about
and
I
think
are
important,
maybe
less
important
to
your
customers
and
say:
I
wanted
to
use
kind
with
cluster
API
in
in
Travis
CI.
Something
like
this
right.
Mmm-Hmm
and
I
have
a
couple
of
projects
where
I
do
that,
but
they
don't
necessarily
have
to
connect
to
anything
in
common
right.
C
There
is
no
like
central
cluster
for
any
of
them
and
I
just
use
kind
and
I
would
prefer
to
use
a
configuration
file
over
arguments
right,
so
I
wouldn't
use
a
cluster
API
object
to
define
the
shape
of
the
cluster.
That
I
want,
and
you
know
fire
it
up
in
Travis,
see
I
turn
it
down.
So
that
sort
of
thing
right
so
I
think
use
case
which
may
or
may
not
be
important.
But
you
know
that
is
something
that
that
becomes
harder.
C
B
It's
same
way
for
testing
what
I
mentioned
before
this
video.
We
need
a
test
be
able
to
create
multiple
test
environments
easily,
so
that
they
do
is
in
kind
is
because
we
we
had
found
that
we
need
to
eg
wait
for
testing
hours,
cluster
management,
stuff
cluster,
but
without
having
real
cluster,
because
that's
just
at
this
point
we
were
using,
for
instance,
creating
cluster
in
OpenStack,
but
is
slow.
B
You
know
the
CIA
test,
last
probably
half
an
hour
while
you
scheduled
stop
and
you
bring
all
the
machines
is
really
heavy
and
you
don't
want
that's
for
developers,
and
you
know
you
cannot
run
that
test
in
your
local
machine,
so
they
are
using
kind,
is
for
developer
for
us
for
speed-up
of
development
or
cross
management,
because
you
can
easily
create
processors
on
demand
and
test
multiple
configurations
and
even
testing.
What
happened
is
over
one
cluster,
you
for
its
and
roll
out
and
update
I,
actually
start
using
time
for
that,
because
it
was
creating
this.
B
This
controller
for
the
boy
in
the
the
certificates,
so
I
need
to
test.
What's
happy,
you
have
multiple!
No
happily,
if
every
move,
an
old
from
the
from
the
cluster,
how
the
controller
manager
this
Emmons
and
then
I
need
a
cluster,
but
it
was
not
super
for
me.
If
you
can
run
anything.
My
laptop
I
didn't
even
need
a
server
for
that.
It
was
running
that
with
for
no.
B
That
was
like
trust,
so
we
realized
that
kindness
MIDI
we're
really
feeling
as
a
testbed
for
more
than
simple
test,
you
can
really
come
out
to
complex
adopts
for
us.
This
is
important.
I
would
say
that
is
probably
one
of
the
things
I
was
slowing
down.
The
development
was
that
the
difficulty
of
making
tests
fast
run
developers
know
you
need
to
wait
half
an
hour
for
the
test.
That's
not
good.
Yeah.
C
Yeah
I
know
very
well
that
what
that
implies,
yeah
absolutely
I,
just
sort
of
you
know,
wanted
to
make
it
clear
to
you
and
that
there
is
there
is
that
one?
You
know
sort
of
the
mental
question
that
you
need
to
ask
yourself.
Any
fewer
happy
was
a
dependency
on
their
on
some
kind
of
temporary
cluster
or
whether
that's
me
me
cube
or
something
else.
Then
then
that's
fine
right
and
then
you
should
be
able
to
use
a
cluster
API
that's
easily.
C
A
Trying
to
get
you
finished
this
week.
Basically,
so
there
is
a
get
book.
I
can't
find
their
URL
I
haven't
been
able
to
for
what
so
David
Watson
from
Samsung
grow
a
implementation
guide,
basically
how
you
would
create
a
provider
from
scratch.
I
think
there's
been
some
issues
publishing
it,
and
but
they
should
I.
B
A
D
A
That
it
shouldn't
be
too
out-of-date.
It
is
based
on
the
AWS,
sweeper
and
I
think
as
your.
It
might
be
another
one
to
look
at
because
they
recently
aligned
with
the
AWS
before
I
do
as
well.
So
they've
just
done
that
a
lot
of
work
to
you,
and
so
there
one
is
pretty
close
to
the
end
of
this
one,
and
probably
the
least
one
as
well
I'm,
not
sure
how
I
think
yeah
so
we're
using
basil
quite
heavily,
which
is
what
is
positives
and
negatives
faith.
A
Yeah
I
think
yeah
like
a
let's
sink
on
slack
and
try
and
get
Bibble
I
think
you're,
definitely
white
like
having
across
the
API
implementation.
What
kind
would
be
great
for
people
who
are
developing
Multi
cluster
management
and
I
think
yeah?
What
anything
we
have
a
properly
tested
even
is
like
not
across
the
API
work
with
multiple
cluster
than
a
single
namespace.
We
think
it
does
bring
never
properly
tested
that
like
these
are
these
are
things
we
need
to
understand
about
the
way
cluster
API
behaves
so
I
mean
this.
C
D
A
A
Might
be
a
little,
but
it
shouldn't
be
too
much
and
so
that
we've
currently
been
burning
down
on
a
proper
everyone
out
for
one
release
of
it,
because
they're
going
we've
been
in
women
out
for
one
for
ages,
but
this
is
the
idea
is
to
a
common
one
of
time.
Scale
is,
might
be
eight
weeks,
but
to
actually
nail
down
what
we
won
out
for
one
looks
like
there
is
a
proposal
to
significantly
change
the
API.
We
don't
know
who'll
do
that
for
me
one
hour
for
the
next
release,
so
that
will
be
quiet.
A
Big
changes
to
the
books,
I
think.
Whatever
changes,
though,
are
right
now
should
be
relatively
minor
and
shouldn't
be
you.
The
book
should
be
good
enough
to
get
started,
and
certainly
you
ask
questions
in
select
if
there's
issues,
but
we
will
definitely
have
to
get
that
book
up
to
date,
for
when
we
run
out
for
one
gets
cut,
sure.
A
A
The
meeting
today
our
goal
and
basically
the
idea,
is
to
save
you
I,
don't
I,
think
a
lot
of
ones
are
similar.
But
if
you
look
at
that,
a
SS
one,
for
instance,
Ukraine
define
a
cluster
and
then
that
goes
out
and
builds
things
like
be
pcs
and
subnets
and
nap
gateways
in
Internet
gateways.
That's
not
suitable
for
a
lot
of
people
like
they
have
their
own
existing
infrastructure
and
want
to
bring
it.
So
what
does
it
actually
mean
to
have
a
cluster?
A
So
the
idea
is
this:
maybe
split
out
some
of
these
objects,
so
we
have
a
control,
plane,
object
and
then
that
might
be
your
choice
of
an
ec2
cube,
ATM,
build
or
eks
and
control
plane
and
then
separate
the
nodes
completely
from
what
a
control
plane
is
and
the
cluster
might
just
have
the
common
information
that
defines
how
those
nodes
of
linked
in
to
a
cluster
and
a
separate
infrastructure
API
that
might
deal
with
provider.
Specific
infrastructure
like
we
PC
subnets,
not
anyways,
okay,.
A
C
Yeah,
that's
interesting.
That's
I
mean
I
kind
of
welcome
that
change,
broadly
and
I.
Think
there
is
still
a
lot
more
to
do,
though,
because
I
think
at
the
moment
the
kind
of
shape
of
questa
API
overall,
as
defined
by
pre
alpha
one,
is,
is
kind
of
hard
to
to
to
use
really
I
mean
the
this
there's
someone
accessor
little
Bosque
there
and
it
just
happened
to
be
in
a
certain
way,
but
I
don't
think
it
has
to
stay
that
way:
they're,
probably
more
user
friendly
things
we
can
discuss
space
a
great
way.
C
C
A
C
It's
kind
of
worms
because
I
was
basically
a
thinking
weather
where
they
didn't
make
sense
to
to
trying
to
prevent,
to
keep
trying
to
define
like
universal
objects
for
all
the
providers
that
may
become
a
union
or
all
the
providers.
Right
so
I've
been
wondering
whether
you
know
whether
we
could
have
like
a
generic
layer
which
basically
represents
a
cluster,
and
that
is
just
a
pointer
to
another
object
like
a
reference.
C
It
holds
a
reference
to
another
object
that
actually
is
defined
in
a
provider
specific
way
so
that
the
so
it's
kind
of
like
and
you
know,
I,
don't
know,
I
mean
I
have
a
did.
I
have
any
examples.
Let
me
just
look
it
up
quickly,
but
you
still
have
time
at
this
college
and
sort
of
briefly
touch
on
other
people
like
yeah.
A
B
Yeah
but
I
mean
let
me
mention
for
its
and
I
didn't
know
the
level
they
already
with
the
API
already
have
this
placeholder
for
provider.
Specific
definition
of
the
node
characteristics
I
was
understanding.
Is
that
for
the
cluster
we
should
have
something
similar
like
we
have
the
front
of
playing
some
basic
information
that
this
needed
for
upon
to
playing
by
the
IP
range
whatever
and
then
have
the
ability
to
having
like
a
more
provider
specific
specifications
off
for
in
some
subnet
or
whatever
physical
I
mean.
B
C
Muted
I
was
trying
to
speak
anyway,
so
what
I
was
trying
to
I
just
trying
to
clarify
what
I'm,
trying
to
say,
I
believe
that,
currently
what
we
talking
about
as
close
to
API
as
is
currently
implemented
by
a
few
providers,
it's
a
it
tries
to
be
a
union
one,
not
being
read
a
union
right.
So
it's
like
there's
the
the
mode
object,
for
example,
and
and
then
there
is
like
providers
back
within
it,
and
each
provider
will
have
a
different
spec.
C
But
I
haven't
seen
a
provider
where
you
know
multiple,
a
thing
where
multiple
providers
you
can
bind
and
it's
kind
of
like
it,
tries
to
be
a
union.
But
it
isn't
graded
right.
That's
what
I'm
trying
to
say.
So
what
I
was
thinking
is
whether
whether
we
could
would
it
be
a
reasonable
idea
and
I'm
asking
you
know
is
so
we
started
discussing
next
anyways,
whether
whether
you'd
find
it
reasonable
to
have
something
like
what
I'm
showing
them
on
the
screen.
C
Right
now,
where
we
have
like
a
high
level
definition
of
a
cluster
provider,
that
sort
of
basically
registers
with
bluster
API
controller-
and
it
says
these
are
the
objects
that
I
have,
which
represent
things
that
that
means
something
to
me
right.
It
just
sort
of
it
registers
itself
as
a
cluster
API
provider
and
and
then,
and
then
that
is
the
sort
of
a
handshake
apart.
But
the
actual
definition
would
be
something
like
this.
C
So
there's
a
cluster
and
it
has,
it
has
a
main
region
and
some
other
metadata,
and
then
it
has
a
spec
and
it
refers
to
some
milk
groups,
and
then
there
are
non
group
definitions
right-
and
this
is
this
is
like
we
provide
a
specific
object
right.
So
this
is
a
this
is
something
provider
knows
about,
and
provider
cares
about
and
something
that
a
user
of
a
particular
provider
would
care
about.
C
C
There
is
some
metadata
and
there
are
all
the
references
which
which
point
at
the
provider
specific
thing
right,
which
is
a
particular
environmental
cluster
which
happen
to
have
a
name
plus
the
two,
and
there
is
potentially
a
shared
thing,
which
indicates
the
status
where
the
cost
is
ready
and
what
sets
API
endpoint
and,
and
they
see
a
certificate
potentially
so
that
kind
of
thing.
So
essentially,
there
is
the
unerring
outer
thing
that
only
holds
a
reference
instead
of
holding
a
union.
Okay.
C
C
B
Sense,
could
we
make
a
lot
of
sense?
Unfortunately,
I
don't
have
this
previous
is
trying
to
make
this
wheel,
so
I
can
now
give
you
a
real
feedback
of
this.
Make
sense
from
the
perspective
of
using
it,
but
conceptually
I
agree
that
this
poor,
cleaner
separation
of
the
common
and
the
specific
part,
is
having
different.
It's
that
way
you
have
the
freedom
of
as
a
provider
or
even
O'grady,
and
your
object
individually
from
it
for
yeah.
C
And
you
you
because
I
mean
I
I,
think
I
think
that
there
are
very
few
things
that
that
are
very
much
in
common
between
providers
that
really
matter
to
the
to
the
end-user.
After
all,
there
are
provider
specific
things
that
really
matter
in
the
context
of
that
provider,
but
there
are
so
many
things
that
that
really
don't
matter
and
the
only
thing
that
matters
is
cabinet
kubernetes.
He
perhaps
has
a
version,
and-
and
you
know
it
has
a
it-
has
an
endpoint.
You
can
connect
to
basically
so
this
this.
C
This
feels
like
enough
to
describe
an
actual
cluster
to
me,
and
then
there
is
the
more
detailed
provide,
a
specific
description
which
is
in
a
separate
object
which,
which
makes
it
simpler
for,
for
the
end,
users
and
the
provider.
Implementers
I
think
so
here
are
some
more
specific
examples
of
those
those
objects
so
and
we
can
see
how
quite
different
they
are
so
for
the
key
s
cluster.
D
C
But
this
is,
this
is
just
a
yet.
This
is
not
trying
to
suggest
that
provider
implementation,
but
it's
just
something
that
that
I've
made
up
as
gonna
go,
spend
10
times,
10
minutes,
thinking
about
the
bare
metal
provider
and
what
I
would
talk
about,
in
contrast
to
without
care
about
in
the
key
s
cluster
right.
C
So
so
the
idea
is
broadly
that
you
know
you
have
the
provider
specific
objects
that
are
entirely
separate
from
from
the
cluster
API
object
and
what
Costa
Rica
defines
is
you
know
the
common
common
sort
of
cluster
and
node
and
load
set
objects
which
which
rely
on
referencing
for
the
initial
implementation?
All
right,
so
you
would
be
able
to
come
up
to
a
cluster
and
type
so
there
it
is
that
essentially
you'd
be
able
to
come
up
with
Western
even
make
some
API
calls
or
type
cubicle
commands
where
you'd
be
able
to
say,
okay.
C
Well,
this
is
my
management
Buster.
Let
me
ask
how
many
clusters
it
manages
so
you'd
be
able
to
ask
that
question
but
you'd
be
able
to
ask
the
question
of
how
many
nodes
there
are
in
each
cluster.
How
do
I
connect
to
each
individual
cluster
rate
and
you'd
be
able
to
just
those
questions
in
a
common
way
a
standard
way,
but
any
anything
that
is
specific
to
the
provider
would
be
would
be
dealt
by
a
dealt
with,
but
I'm
provided
by
provider
basis.
C
So
basically
that's
the
idea,
so
you'll
be
able
to
say
you
know
you
could
all
get
clusters
and
could
all
get
notes
that
so
it
could
all
get
notes
or
whatever
I
mean
or
whatever
we
decide
to
call
those
machines
or
anything.
So
that's,
that's
roughly.
The
idea
and
I
wanted
to
run
it
by
a
few
more
people
before
I
kind
of
presented
till
they
by
the
Rodin's
I.
Think.
D
C
Is
a
draft
of
how
cluster
API
could
look
like
if
we
were
to
sort
of
stop
making
it
stop
trying
to
make
it
the
union
of
all
the
providers
which
it
never
is
going
to
become?
And
you
know
to
find
a
very
lean.
Very,
very
lean
object,
rather
a
lean
set
of
objects
that
that
would
be
in
common
and
and
the
rest
would
be.
C
You
know,
implemented
on
there
on
through,
through
all
the
references
like
this
in
terms
of
the
be
the
outer
API
and
then
the
there
should
be
some
kind
of
inner
API,
because
we
have
to
like
communicate
back
the
the
endpoint
and
certificate
data
and
stuff
like
that,
which
I
think
is
quite
important.
Yeah.
C
What
is
that?
The
this,
this
the
status
field
for
the
cluster
I
lost
it
here.
So
so,
if
we
wanted
to
tell
it
to
tell
us
together
our
health
and
end
points,
there
would
be
another
API
for
for
the
provider
to
communicate
to
the
to
the
cost
rate
controller.
So
this
this
is
roughly
the
idea,
and
so
it
sounds
like
you
folks
think
that
this
is
the
substantially
plausible
my
dear
be,
did
you
have
any
thoughts.
C
B
B
A
C
A
It
has
been
in
the
means,
so
there's
that
there
is
also
been
talk
of
the
generic
provider.
So
I
think
this
is
pretty
relate
to
the
bare
metal
thing
that
I
think
probably
quite
is
is
a
lot
of
the
pointers
are
actually
implementing
the
same
things
over
and
over
again,
yeah
just
got
another
delivery.
Yeah.
A
Yes,
so
the
generic
poyo
is
going
to
take
those
sort
of
common
bootstrapping
issue
with
issues
and
initially
will
be
in
a
separate
repository,
and
the
idea
is
to
then
experiment
with
web
hooks
for
provider
specific
implementations
to
plug
into
so
it's
a
kind
of
similar
to
what
yeah
except
it
runs
like
up
yet
so
this
is
another
way.
That's
been,
you
know
this
wiped.
You
attack
the
same
problem
and
you
know
I,
think
I.
B
You
mention
it's
interesting
because
this
your
etiquette,
we
have
because
the
documentation
of
node
architecture
I,
can
recall
where
I
think
it's
a
book.
They
mention
that
they
need
that.
You
have
deep
provider
that
you
have
the
actuator,
which
is
the
one
and
actually
and
actually
the
original
is
basically
a
simple
unity.
Crude
API
create
they
need.
B
Basically,
my
understanding
that
is,
you
can
separate
distributing
far
but
interestingly,
according
to
the
jeweler
proportion,
it
is
like
what
they
will
be
changing
is
probably
more
this
provider
specific
part,
because
the
other
issue
net
across
a
I
needed
to
create
these
specific
cost
with
the
experimental
processor.
So
you
will
talk
to
the
actuator,
but
I
think
that
this
idea
is
already
somewhere.
I,
don't
know
in
the
API
itself,
but
only
the
idea
has
been
around
so,
for
him
does
probably
make
a
lot
of
sense,
because
this
interface
need
to
be
personally.