►
From YouTube: Kubernetes SIG CLI 20200325
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
Okay,
good
morning,
good
evening,
good
afternoon,
depending
on
where
you
are
it's
March
26
25th-
and
this
is
another
of
our
bi-weekly
six,
you
like
meetings,
my
name
is
Matty
and
I'll,
be
your
host.
Today,
I
don't
have
any
particular
announcements
other
than
I
do
hope.
Y'all
are
all
great
and
you
know
safe,
and
you
know
all
the
best
to
everyone
and
I
hope
you
will
be
secure
and
you
know
safe
in
the
next
couple
of
weeks.
In
the
tough
times
I.
A
You
know
we
did
not.
The
last
one
was
from
February
19
just
crawling
through
the
agenda
so
yeah.
Definitely
it
is
about
time
to
have
fun,
and
that
would
be
like
literally
the
last
possible
time.
Yeah
it'll
be
it
will
be
even
further
than
that.
Okay,
so
definitely
next
week,
we'll
do
a
bug.
Scrub
call
thanks
for
the
reminder.
Eddie
and
Eddie
will
be
organizing
that
one
so
get
Eddie.
Can
you
make
sure
to
send
out
an
invite
to
six
CLI
so
that
people
don't
forget
about
that?
One
yeah.
B
C
A
B
A
D
Sounds
good
share.
D
D
C
C
D
You
need,
oh,
maybe
just
five,
seven
minutes
and
one
who
also
wanted
to
get
people
on
up-to-date
with
our
progress,
but
also
just
maybe
stimulate
some
discussions
about
what
how
we
all
can
be
thinking
about.
You
know
graphical
experiences
for
kubernetes,
so
just
five
or
seven
minutes
to
be
fine.
Okay,.
D
Okay,
this
works.
How
is
that
look?
Looks
right,
okay,
great
so
just
just
a
20
second
background.
So
Kui
is
a
project
for
allowing
us,
hopefully
more
easily
and
readily
to
take
existing
CL
eyes
and
give
them
a
graphical
enhancements,
and
so,
for
example,
here
I
am
in
Kui
and
we're
running
Kui
now
in
a
kind
of
trilling
replacement
mode.
D
There's
alternate
modes,
but
I'll
start
with
this
one,
so
it
has
its
own
little
terminal,
I,
usually
Kerber
Nettie's
get
pupcake
and
get
pods
and
I
get
back
a
table
as
you'd
expect.
But
the
table
has
some
decoration
enhancements
like
badges,
but
it
also
has
click
ability.
So
if
I
click
on
one
of
the
pods
I
get
some
additional
details
about
it,
the
components
of
that
pod
I
can
go
from
the
raw
ya
mole
to
more
wrap-up
roll-up
kind
of
views.
I'm
gonna
trying
to
summarize
the
information
that
they're
in.
D
We
also
have
the
ability
to
take
some
of
this
information
and
cast
it
into
more
graphical
form.
The
standpoint
of
usage,
so
you've
probably
all
familiar
with
the
on
the
output
of
coop
cuddle
help,
and
so
we
can
also
decorate
that
so
here,
I'm
going
to
we
have
a
couple,
is
getting
there.
You
can
have
to
go
through
the
settings,
menu
or
just
type.
Okay
and
you'll
be
able
to
see
some
hand
since
there
as
well
so
here.
Well,
we've
done
here
is
a
basically
screen
scraped.
D
The
raw
output
of
coop
cuddle
and
just
recast
it
into
a
graphical
form,
and
so
I
can
then
start
traversing.
Some
of
this
information
I
can
go
down
and
if
I
want
to
view
the
out
for
I'm
creative
expose
that
click
and
I've
navigated
out
to
the
next
level,
and
and
just
to
just
to
repeat
the
story
here,
there's
nothing.
We
haven't
really
invented
anything
here.
From
the
standpoint
of
the
content.
All
the
content
is
exactly
the
content
you
would
see
from
the
normal
Kuato
command
line.
D
Oh
we've
done
is
a
scripted
into
into
a
graphical,
HTML
kind
of
form,
but
now
I
can
begin
to
navigate
some
of
this
more
complex
help
kind
of
structure,
both
in
the
standpoint
of
parceling
out
the
sort
of
the
piece
parts
of
each
individual
home
screen,
but
also
begin
to
start
navigating
between
the
elements
of
the
the
command
hierarchy.
So
we
can
answer
that
as
well,
so
I
I'm,
hoping
that
that
we
can
start
thinking
about
how
we
can
even
take
this
to
step
further.
D
So
to
really
help
new
users
understand
not
just
sort
of
the
the
basics
of
Kupa
to
have
maybe
or
live
examples
or
anything
you
guys
might
think
of
of
how
we
could
enhance
this
even
to
the
next
level.
What
would
you
want
to
add
to
these
kinds
of
help?
Screens
said
that
you
would
you
were
thinking
about
before,
because
you
were
limited
to
an
ascii
context.
Could
we
have
even
more
more
deep
connections
there
there's
also
ability
when
you
create
or
delete
resources,
we
can
of
some
sort
of
live
feedback
as
to
their
state.
D
What
we're
not
doing
yet,
or
things
like
having
really
deeper,
more
meaningful
connections
with
customized,
so,
for
example,
we
cannot
right
now
if
I
do
a
fly
Kay,
it
just
shows
the
raw
output
of
of
customized.
But
there's
nothing,
that's
fancy.
You
know
nothing
fancied
up
about
it,
nothing
clickable!
It's
all
this
raw
text,
and
so
that's
the
case
where
you
know
I
think.
D
In
the
case
you
saw
previously
of
maybe
of
having
more
of
a
form
based
presentation
to
the
data.
This
form
based
presentation
is
still
new.
It's
a
new,
in
fact,
that
it
doesn't
respond
to
font
zooming.
So
there's
a
bug
there,
but
also
for
based
presentations.
This
could
also
be
presentations,
maybe
in
the
case
of
customize,
where
there's
sort
of
multi-part
views
where
you
can
link
together
the
customize
specification
to
the
base
layers
and
having
more
graphical
connections.
D
You
know,
but
the
idea
here
is
that
hopefully,
with
this
kind
of
framework
underlying
it
all
these
kinds
of
discussions,
we
can
have
more
readily
and
we
can
toss
these
ideas
around
and
make
progress
very
quickly.
I'm.
The
framework
will
allow
us
to
add
new
commands,
for
example,
or
decorate
existing
commands
in
a
nice
fashion.
So
I
just
wanted
to
sort
of
get
that
you
know
in
in
the
in
your
guys
thought
process.
So
we
can
start
opening
up
issues.
D
The
COO
interface
is
to
digest
that
output
of
that
raw,
CLI
and
decorated
in
some
way,
so
we're
not
we're
not
tapping
at
all
into
anything
implicit
with,
for
example,
the
underlying
API,
for
example,
for
kubernetes
or
for
IBM
cloud,
or
for
Google
Cloud,
where
you're
just
using
the
CLI
in
a
peer
and
OC
and
a
purely
unadulterated
fashion,
which
has
some
limitations.
But
that's
a
lot
of
benefits
for
now.
That's.
C
D
Yeah,
it's
really
really
just
sort
of
screen
shaping,
so
all
the
Help
Center
helps.
If
I
showed
you
it's
just
a
matter
of
leveraging
all
the
great
work
you
guys
have
done
of
making
the
fact
that
the
coop
cuttle
output
is
so
easy
to
parse.
That
job
was
actually
relatively
straightforward,
helm,
I
know,
there's
there's,
there's
words
here
but
helm,
and
so
we
have
helm
as
well
and
we
have
OC
and
the
helm
out,
but
is
is
pretty
good.
It's
I.
Would
it's
it's
in
some
cases
that
the
possibility
is
a
little
bit
less.
D
So
the
reason
why
this
environment,
subsection
is
not
pulled
out
to
a
top-level
subsection
on
the
left
is
because,
in
all
of
the
cases
they
put
a
single
new
line
between
the
the
title
of
the
subsection
and
the
content,
but
for
some
reason,
helm
in
one
case,
but
two
new
lines,
so
we
did
weren't
able
to
parse
it
properly
or
so.
Home
is
definitely
less
consistent
in
coop
cuddle.
But
it's
pretty
good.
C
D
That's
I
think:
that's
definitely
something
we
should
have
we
they
right
now.
The
idea
is
that
if
it
omits
tables
and
look
like
kubernetes
tables,
you're
guaranteed
to
be
first
that's
more
or
less
the
way
it
is
now
for
IBM
cloud.
They
actually
there's
CLI
as
a
guest
Jason
option,
which
is
kind
of
like
the
Oh
Jason,
uyama
kubernetes.
And
so
even
though
the
IBM
cloud
tables
were
hard
to
parse,
we
just
dynamic
in
that
case
just
dealt
down
to
the
raw
information.
D
Karati
says
the
server-side
printing,
which
complicates
matters.
We
want
to
leverage
that
as
much
as
possible.
So
that's
what
we.
We
dispersed
the
tables
in
the
current
form
so
that
we
can
leverage
whatever
server-side
printing
that's
the
Erinyes
might
have,
but
we
should
be
thinking
about
so,
for
example,
for
customize.
There's,
there's
sort
of
a
principle
here.
D
D
A
D
So
I
think
something
that's
just
a
cap.
You
can
probably
pretty
easily
fill
it
with
with
apply
K
as
well,
but
there's
definitely
some
deeper
issues
there
that
we
have
to
work
through,
for
example,
if
you're
applying
a
whole
subdirectory,
you
know
you
can
do
that
with
with
employ
F,
but
we're
not
currently
getting
the
status.
The
recursive
status
of
all
of
those
resources,
so
in
the
short
term,
I
think
that
we're
gonna
be
I.
D
Think
customized
seems
like
a
pretty
pretty
low
hanging
fruit
for
us
to
be
looking
at
next,
so
any
thoughts
you
have
there,
whether
its
forms
or
anything
you
guys
have
I,
definitely
welcome
you
to
be
opening
up
issues.
This
is
our
current
repo.
It's
still
host
underneath
IBM
/
GUI,
where
we
have
we're
gonna
work
on
Rijo
stting
that
and
hopefully,
in
the
next
couple
of
weeks.
We
just
have
to
arrange
who
the
owners
are,
and
the
contributors
and
all
that
so
hopefully
in
the
near
future.
C
Great
yeah:
let's
follow
up
on
customized
we're
doing
some
work
there
like
pr's,
are
starting
to
come
out
which
are
might
make
this
simpler
by
attaching
metadata
so
that
program
such
as
cuy
can
identify
things
like.
Oh,
this
was
a
name
prefix
and
it
was
inserted
by
this
file
or
that
sort
of
stuff.
So
there's
no
more
information
there.
You
can
take
advantage
of
soon
yeah.
D
B
B
Did
you
last
week
you
said
you're
having
trouble
with
spawning
the
plug-in
and
packaging
it?
What?
Oh?
Yes,
oh
yeah,.
D
Sorry
for
thanks,
thank
you
very
much.
Who
was
that
talking?
Sorry,
Freddy,
OAD,
yeah
I.
Thank
you
for
reminding
me
of
that.
That's
why
she
kept
demo.
I
may
just
give
a
quick
little
furniture
man,
that's
sort
of
the
most
important
part.
Thank
you
so
in
my
mind,
so
everything
I've
shown
you
so
far-
is
sort
of
with
a
Trillin
or
replacement
load
which
I'm
not
I'm,
going
to
be
the
first
to
admit
for
a
desktop
kind
of
scenario,
isn't
the
most
attractive
thing,
but
for
our
browser-based
deployment,
this
is
pretty
nice.
D
In
fact,
we
have
a
there's,
an
IBM
product
which
is
hosted
us
in
a
browser-based
hosting,
hosted
environment
and
there,
of
course
you
need
a
terminal
replacement
because
there
was
no
terminal
running
in
a
in
a
browser,
but
for
most
local
developers,
they're
not
gonna
want
to
replace
their
zsh
or
whatever
fancy.
You
know,
crafted
local
development
experience
and
I'm
one
of
those
people.
So
we
can.
We
can
address
that
as
well.
D
Via
you
know,
crew
and
the
and
the
COO
cuddle
plug-in
mechanism,
and
so
we
have
a
what
we
call
a
kind
of
a
pop-up
mode.
So
here
I
am
a
little
bigger
I'm
just
to
my
stand
and
Mac
OS
terminal,
and
you
can
see,
we
can
very
quickly
pop
up
a
window
in
response
to
certain
commands
and
now
I
can
now
keep
this
window
as
a
permanent
sort
of
a
fixture
in
my
environment
or,
if
I'm
happy
with
with
the
result.
This
and
I
can
do
all
the
standard.
D
You
know
navigational
stuff
I
was
doing
before
if
I'm
and
one
if
I'm
done
with
that
talk,
I
can
close
it
out
and
be
back
to
my
normal
CLI
experience
or
if
I
want
to
keep,
keep
it
around
and
and
sort
of
riff
on
that
and-
and
you
know,
issues
other
related
commands,
you
can
sort
of
stick
in
that
environment.
So
this
is
what
we
call
a
pop-up
client,
which
you
can
see
it
as
the
bottom
input
kind
of
experience,
as
opposed
to
a
standard
terminal
where
the
input
and
output
are
intermixed.
D
And
so
this
so
you
see
I,
need
a
coupe,
karoku,
II
and
so
investigations
we
had
done
and
two
weeks
ago
my
tried
to
make
it
so
that
we
could
just
basically
put
the
cuy
electron
app
itself.
The
binary
have
it
be
the
lead,
the
plug-in,
and
it
turns
out
that
that
doesn't
work
just
in
Mac
OS,
because
I'm
Mac
OS
the
the
turns
out
that
you
can't.
D
So
that's
the
short
answer
to
a
question
any
that
it
turns
out
that
it's
our
fault
or
someone's
underneath
us,
but
not
certainly
not
coo,
cuddle
so
and
so
for
the
time
being,
I
think
we're
it's
gonna
have
to
deal
with
having
a
super
small
wrapper
script,
at
least
from
a
coalesce
to
work
around
that
problem.
But
the
good
news
is
that
it's
a
it's
a
tiny
little
wrapper
script
basically
and
that
robber
script
will
let
us
then,
and
let
crew
have
whatever
symlinks
it
wants,
and
we
should
be
pretty
good
to
go.
D
That
was
a
relatively
nice,
although
not
ultimately
not
the
ultimate
solution
about
a
pretty
nice
solution
to
it.
From
a
KU
installation
standpoint
we
still
have
I
know.
It's
don't
like
to
do
this
for
a
while
now,
but
so
cou
clearly
does
not
work
for
many
good
reasons:
unzipping
tar,
balls
that
include
symlinks
and
for
Linux
and
windows.
That's
okay!
D
It's
definitely
require
a
lot
of
diligence,
so
we
need
to
either
do
that
work
or
we
need
to
figure
out
an
ultimate
solution
which
might
this
be
for
now,
if
you
want
cooee,
just
curl,
download,
cuy
and
and
similarly
get
in,
but
we
could
at
least
have
a
short-term
answer
to
that
short
of
fixing
up
crew
to
handle
some
links,
which
is
a
scary
proposition.
Given
all
the
security
holes
that
have
been
found
there.
C
C
E
Hey
this
is
Matt
I
can
I
can
speak
too
I.
Think
part
of
why
I
came
last
time
asking
some
questions
Maya.
My
team
working
on
the
airship
project
is
interested
in
leveraging
customized
for
all
the
great
things
it
does
and
for
also
probably
doing
things
like
taking
advantage
of
some
of
the
more
advanced
plugins
that
have
been
getting
created
recently
around
replacement
and
substitution
and
as
we
as
we've
been
integrating
with
customized
and
keeping
sort
of
starting
to
keep
more
tabs
on
the
development
of
the
project.
E
We've
seen
a
lot
of
work
going
on
on
some
things
that
you
know
from
an
outside
perspective,
seem
kind
of
parallel
to
the
the
bulk
of
customized
functionality
around
config,
the
config,
sub
command
and
functions
in
addition
to
plugins
and
those
sorts
of
things.
So
we
kind
of
wanted
to
just
understand
a
little
bit
where
the
customized
team
sees
the
trajectory
of
these
moving
parts
heading
in
the
future,
so
that
we
can
so
that
we
can
align
align
to
that
appropriately,
and
we
have
I
mean
we
can.
E
C
Yeah,
it's
great
I,
think
some
stuff
is
more
exploratory
than
others,
so
anything
being
developed
out
of
config
I
think
it's
at
the
stage
where
we're
trying
to
explore
the
primitives
that
might
make
sense
across
holistically
across
6ui.
A
lot
of
that
work
is
derived
from
experience
both
on
coop
control
and
customized.
So,
for
instance,
I.
The
center's
and
substitutions
are
really
close
to
ku
control,
centers
much
more
so
than
they
are
to
anything
in
customized
but
understanding
like,
but
at
the
same
time
they
operate
against
configuration
rather
than
remote
resources.
C
The
I
think
some
of
the
things
we're
learning
about
those
explorations
are
that
folks
are
typically
trying
to
build
a
system
and
and
they're
gonna
have
a
lot
of
different
needs,
and
it's
it's
usually
fitting
into
whatever
their
organization's
process
is
right.
There's
other
stuff
going
on.
There's
the
CIC
CD
system,
maybe
have
automated
deployments.
Maybe
you
don't?
Maybe
you?
C
Maybe
you
have
one
team
that
develops
like
the
blueprints
or
like
the
way
to
write
applications
for
your
organization
and
everyone
copies
those
and
then
doesn't
really
change
them
that
much
or
maybe
everyone's
writing
it
from
scratch
or
maybe
you're
generating
it
from
Java
like
there's
something
called
decorate.
I
think
someone
just
showed
me,
which
is
like
generating
configuration
directly
from
annotations
on
code
I'm,
sure
other
languages
have
the
same.
So
there's
lots
of
different
ways.
Folks
are
doing
stuff
and.
C
One
thing
I
think
we've
kind
of
observed
is
that
a
lot
of
the
feature
requests?
No
no
I
shouldn't
say
a
lot,
but
some
class
of
feature
requests
for
customized
are
trying
to
make
it
their
system
right
and
that
it's
like
okay.
We
need
some
way
of
pulling
the
image
that
we
just
built
and
substituting
it
in
just
in
time
right
and
so,
like
a
request
would
be
well.
C
How
do
I
make
customized
pull
the
image
from
the
environment
or
some
other
source
and
plug
it
into
like
how
customize
natively
support
that
thing
right
and
the
need
is
definitely
there
like.
We
totally
want
to
support
those
were
clothes,
because
everyone
has
them.
However,
making
customized
work
with
every
one
of
those
workflows
directly.
C
I
think
it
means
it
won't
work
for
it's
either
going
to
become
very
complicated
as
it
tries
to
support
kind
of
every
sort
of
system,
and
so
what
we're
starting
to
explore
is
what,
if
we
just
kind
of
keep
the
customized
API
as
it
is
largely
then
in
the
Explorer,
before
launching
in
to
saying
okay,
we're
going
to
solve
this
directly
and
customize
by
introducing
a
new
concept
here
like
whole
image
from
environment,
or
something
like
that.
What
if
we
look
at,
what
can
we
build?
C
That
would
compose
with
customize
and
kind
of
keep
the
layers
the
way
they
are
and
not
expand
the
scope
of
necessarily
what
customize
is
doing,
and
so
the
general
problem
right
is:
how
do
I
substitute
information
from
my
environment
into
my
configuration
and,
if
you
view
customize
as
just
more
configuration
it's
just
a
way
of
representing
configuration
and
factoring
it,
then
the
problem
starts
to
look
different
right.
It's
like,
instead
of
asking
customize
how
do
I
pull
the
image
tag
from
an
environment.
Variable
customized
just
defines
the
image
tag.
C
The
way
it
does
today,
which
is
as
a
field
customization
animal
but
there's
a
tool,
a
separate
tool
that
substitutes
it
in
and
that
tool
can
substitute
things
arbitrarily,
not
just
in
the
image
field,
but
in
other
pieces
right
and
then
I
think
this
actually
allows
a
lot
more
flexibility
in
how
we
combine
these
pieces.
So
that
is
the
context
for
hey,
there's
stuff.
That's
not.
That
seems
very
different
from
customized
that
we're
building
inside
the
customized
rebo.
C
E
So
if
I
were
to
that
and
that
I
think
that
makes
sense
to
me
so
if
I
were
to
sort
of
say
that
back
to
you-
and
you
can
tell
me
if
I'm
understanding
it
right
or
wrong,
the
config,
the
config
work
is
geared
around
making
hooks
for
external
tooling
to
to
participate
in
in
sort
of
the
substitution
process
and
set
things
up
so
that
then
customized
can
continue
to
do
what
it
does
today
in
in
taking
taking
that
data
and
and
customizing
the
documents
with
it.
Yeah.
C
And
I'd
say
it's
not
again.
Yes,
all
that
is
is
that's
right
on
right
and
the
one
thing
I
just
want
to
clarify
is
that
it
is
not
exclusively
to
that
particular
problem.
In
the
sense
it
is
I
think
looking
at
a
separate
layer
which
customize
would
benefit
from
having,
but
isn't
it
isn't
just
customized
right?
You
can
imagine
you
don't
want
to
use
customize
or
you're,
not
ready
to
use
customize
yet
or
you're,
not
using
customize.
For
this
one
piece,
then
the
substitution
mace.
F
What
would
you,
how
will
you
define
a
criteria
to
determine
you
know
when
we
looked
at
I
work
with
Matt?
When
we
looked
at
customize
a
lot
of
times
we
find
ourselves
assigning?
Well,
we
can
do
this
if
we
write
our
own
custom
plugin
right
for
customize,
so
some
plugin
that
we
that
does
what
we
want
it
to
do,
to
do
the
replacement
and
do
whatever
generic
CR
replacement
whatever.
But
so
now
we
see
all
this
config
and
all
these
function
stuff.
F
So
where
will
you
draw
the
line
of
when
is
something
or
you
should
go
down
the
line
of
creating
your
own
plugin
for
that
function?
And
you
know
we
can
talk
to
custom
I,
see
it
whatever
we're
talking
about
is
generic
enough.
They
would
even
fit
within
the
customizing
for
repo
or
or
marketplace
a
plug-in
or
whatever
you
call
it
versus
you
know
you
should
look
at
the
config
and
forget
about
your
custom
plugin.
C
If
you
don't
mind,
I'd
like
to
answer
that
question
by
kind
of
giving
you
the
architecture
as
I
see
it
I
in
and
then
like
each
person,
it's
going
to
be
a
combination
of
taste,
crowd
and
preference
effectively
and
the
specifics
of
the
problem.
In
most
cases
the
architecture
as
I
see
it
is
you
essentially
have
three
tools
available
to
you
in
in
or
three
layers
isn't
maybe
another
way
of
looking
at
it.
C
C
One
way
of
doing
pure
factoring
to
make
that
somewhat
we're
usable
is
to
have
a
base
that
has
you
know
effectively
the
app
and
then
users
have
some
are
provided
some
like
base
set
up.
Customization
Hamelin
patches,
those
patches
come
predefined,
with
kind
of
the
stuff
that
you
as
the
publisher
of
the
reusable
module.
What
would
want
to
have
people
to
override?
So
that
might
be
the
image.
If
it's,
you
know,
module
for
running
a
particular
language
or
something
if
it's
for
running
something
like
Prometheus,
the
image
wouldn't
necessarily
be
something
exposed.
C
So
that's
just
data
right
and
now
that
will
get
you
so
far,
but
that
still
means
someone
has
to
go
in
and
use
their
text
editor
and
work
with
these
api's
directly,
and
so
that
might
not
make
sense
in
the
in
in
a
few
in
the
case
of
well,
we
want
to
give
this
to
users,
but
really
they
should
only
be
setting
these
three
things
right
and
really
they
have
this
nice
workflow.
Today,
where,
like
we
have
this
platform
we
built
where
they
just
run.
C
C
Then
they
get
this
experience,
they
may
want
this
experience
where
those
are
provided
as
higher-level
for
them
right
and
so,
and
maybe
they
want
to
do
it
from
the
CLI
and
they
want
to
do
it
possibly
from
scripts
or
automation.
They
want
to
automate
this
as
part
of
this
guy's
new
system.
So
this
is
something
where
just
the
factory
alone
won't
do
a
great
job,
and
this
is
one
area
where
people
start
to
say:
oh
I
want
to
be
able
to
float
from
this
environment.
C
I
want
to
pull
it
from
these
other
areas,
so
that
I
can
hook
in
I
can
hook
external
sources
into
my
configuration
without
using
set
as
effectively
they
ask
there,
and
those
can
be
done
in
many
cases
through
effectively
looking
at
the
schema
and
marking
up
with
metadata,
and
so
you
couldn't
say
something
like
oh
yeah.
The
schema
of
the
object
is
this
and
I.
If
I
want
to
set
the
replicas
I
can
add
to
the
schema.
C
The
you
can
do
a
lot
with
the
data
in
terms
of
being
able
to
build
other
systems
that
hook
in
and
can
manipulate
like
high-level
notions,
but
that
that
will
only
get
you
so
far.
Right
like
you
can
actually
go
cry
to
credit
ways
with
that
you
can
maybe
substitute
a
value
into
a
bunch
of
different
fields
as
a
string.
C
The
one
I
just
described
is
effectively
what
working
out
with
config,
setters
and
plugins
are
a
restricted,
so
they're
not
like
a
full
run,
your
own
binary
to
do
whatever
you
want.
They're
actually
have
a
restricted
view
that
says
and
mirrors
effectively
what
the
controllers
in
the
kubernetes
cluster
does,
which
is
you
can
read
and
write
resources
right
with
a
controller
controller
queries
the
kubernetes
api
or
uses
the
informer
watch
cache
to
get
a
collection
of
resources.
C
Then
it
looks
at
them,
make
some
decisions
and
then
write
some
resources
back
to
the
cluster
right,
and
so
what
we're
looking
at
is.
Okay.
That
model
works
pretty
well.
It
is
basically
we've
been
able
to
implement
everything
in
kubernetes
that
we
need
to
implement
just
using
that
model,
plus
s
web
hooks
and
a
couple
other
pieces
compose
with
it
right,
but
the
the
notion
of
reading
and
writing
resources
as
the
the
way
you
implement
complex
systems
is
held
up
pretty
well,
and
so
this
is
the
same
model.
C
Plugins
use
it's
just
the
inputs
and
outputs
are
a
bit
different,
plugins
the
for
customize
user.
They
read
from
partially
customized
resources
and
then
they
emit
back
out
to
customize,
and
so
these
actually
end
up
are
invoked
as
part
of
the
customized
build
process
II,
and
so
those
would
be
used
like
if
you,
if
you
need
to
do
something
like
create
a
new
resource,
remove
a
resource.
Do
deep
structural
changes
to
resources.
Plugins
are
going
to
be
your
friend
there,
especially
if
you
want
to
do
some
specialized
for
your
system.
C
Functions
are
something
that
we
are
looking
at
as
a
growing
out
of
plugins
and
saying.
Okay,
the
model
is
actually
really
I.
Think
solid
here
for
taking
that
API
for
taking
that
model
of
the
controller
model,
but
applying
it
to
configuration
files
and
it
can
be
used
for
actually
much
more
than
just
in
the
context
of
customized
build.
C
It
can
be
used
to
actually
as
part
of
a
CI
CD
system
to
validate
the
output
of
customized.
After
it's
been
customized,
for
instance,
you
can
apply
coop
Val
right
is
kind
of
an
example
of
something
we've
been
looking
at.
Having
a
function
for
I
think
we
have
a
function
for
it
already.
They
could
write
back
to
the
package
right.
So
the
same
way,
a
controller
writes
back
to
the
API
server.
It
reads
from
the
API
server
and
writes
the
API
server.
E
A
quick
question
then,
and
that
helps
the
the
the
model
and
API
structs,
and
things
like
that
that
are
used
today
between
sort
of
core
customized
functionality
and
then
the
kml
api
and
objects
are,
are
there's
sort
of
different
sets
of
objects
that
do
similar
kinds
of
things?
Do
you
you've
outlined
kind
of
two
related,
but
different
use
cases?
Do
you
see
them
converging
on
a
common
model
and
api,
or
do
you
see
them
kind
of
continuing
as
as
is
today
no.
C
The
libraries
in
kmo
are
made
to
replace
the
ones
in
customizing
I'd
like
we
are
just
starting
now
to
do
that.
Migration!
There's
a
if
you
look
in
the
pr
list.
I
think
the
third
one
in
the
list
is
the
first
version
of
this,
the
libraries
and
customize
and
talk
about
like
the
infrastructure,
libraries
we
used
to
build
customized
now
our
built
on
serializing
resources
through
maps
golang
maps,
for
instance.
C
So
this
is
one
example,
and
that
drops
all
comments
and
structure,
and
so
that
means
like
if,
when
you
customize
run
customize
on
something,
it's
gonna
just
drop
a
bunch
of
stuff
and
reorder
stuff
in
weird
ways,
and
it
won't
look
like
what
you
put
in
to
customize.
The
libraries
in
kml
are
built
on,
go
the
go
Yemma,
libraries,
the
most
recent
version
of
them,
which
has
primitives
that
allow
you
to
manipulate
comments
and
structure
and
the
format
right.
C
C
I
would
like
to
then
follow
up
by
moving
on
to
the
open,
API
libraries
there's
a
bunch
of
libraries
in
Campbell
for
working
with
structure
of
objects
and
beginning
to
take
augment
what
customize
uses
to
determine
where
to
substitute
different
things
or
add
labels
or
add
annotations
with
the
actual
schema.
So
we
can
actually
look
at
field
to
say
yep.
This
is
definitely
a
label
selector
without
hard
putting
in
someplace
else.
E
So,
just
sort
of
give
you
a
little
context
and
to
where
my
question
was
coming
from
to
like
a
I
I
think
the
way
that
you
outlined
the
different
use
cases
earlier,
at
least
for
for
kind
of
our
interest
right
now.
I
think
we're
more
concerned
with
what
we
think
of,
at
least
as
being
those
core
factoring
kinds
of
concerns,
rather
than
integrating
to
external
external
systems
and
and
and
environmental
injection.
And
things
like
that.
E
But
we
we'd
like
to
do
some
additional
just
operations
from
a
substitution
standpoint
that
aren't
at
least
not
yet
supported
out
a
box
with
with
customize,
which
is
part
of
what
drew
us
to
that
replacement.
Transformer
plug-in,
which
today
is
kind
of
packaged
up
as
an
example,
and
it
wasn't
quite
clear
to
us
whether
that
was
on
sort
of
a
trajectory
to
become
an
built-in
plug-in
functionality
or
if
it
was
going
to
be
reworked
into
a
you
know,
from
sort
of
a
POC
to
something
else,
so
that
what
we
kind
of
did
is
a
just.
E
An
exploratory
step
was
to
take
that
plug
in
and
then
wrap
it
up
as
a
function
and
map
from
the
the
function,
KML
inputs
and
outputs
to
the
customized
inputs
and
outputs
that
the
that
the
plug-in
expects,
and
so,
if
I,
was
kind
of
interpreting.
What
you're
saying
correctly,
if
it
there's
a
separate
question
of
whether
we,
whether
you
know
we'll,
need
to
maintain
a
like
a
separate
plugin
for
that
kind
of
plug-in
functionality
right
for
that
substitution
functionality.
E
C
I
mean
we're
gonna,
keep
backwards,
compatibility
for
the
plugins
or
at
least
there's
like
a
deprecation
policy.
So
we're
not
gonna
like
pull
out
the
rug
from
under
people,
but
the
KML
one
is
the
one
you're.
Probably
gonna
want
to
be
on
like
that.
We're
never
going
to
be
able
to
support
keeping
structure
and
comments
with
plugins,
because
plugins
are
gonna
drop
all
that
stuff
during
serialization
Cranston
yeah.
E
Cool
that
makes
sense,
then
then
I
guess
the
the
follow-on
question
is
for
that
specific
example
of
the
replacement
transformer
and
one
of
the
things
that
we
liked
the
best
about
it
is
the
the
tree
substitution
or
replacement
that
it
does.
Do
you
have
specific
plans
from
a
plug-in
or
function
or
any
other
or
built-in
kind
of
standpoint,
for
for
that
kind
of
functionality
with
customized.
E
Cool
that
makes
sense
and,
of
course
anything
we
do
on
a
you
know,
substitution
functionality.
We
would
do
in
a.
We
would
try
to
do
in
a
you
know,
generic
and
reusable
way
that
would
align
to
our
best
understanding
of
what
what
customized
wants
or
how
it's
going
to
be
oriented
in
the
future.
So
it
could
be
reused
by
others
or
integrated
in
in
the
future
in
some
way,
I
think.
C
C
G
Maybe
briefly,
but
what
do
you
have
an
initial
idea
of
how
you
might
like
compose
secret?
Do
you
know
with
customized.
C
Great
question
secrets
are
actually
something
that's
been
really
there's,
not
a
single
agreement
on
what
the
white
way
is.
I
think
I've
talked
to
a
lot
of
people
who
have
a
lot
of
different
opinions,
and
this
is
one
area
where
a
hesitant
to
do
much
more
for
now,
because
there's
so
many
ways
of
doing
it.
The
one
of
the
ways
I've
heard
is
effectively
don't
store
secrets
like
just
manage
secrets
completely
separately
from
everything
else.
You
should
have
a
separate
system
entirely.
This
is
not
me
by
the
way
endorsing
this.
C
A
F
H
May
actually
make
our
COO
control
code
more
reusable
and
just
just
to
give
a
quick
background
if
you
wanted
to,
for
instance,
use
some
some
of
the
coop
control
code
in
a
controller.
One
of
the
simplest
ways
would
be
to
create
the
options
associated
with
that
command
and
then
fill
in
the
options
struct,
maybe
with
a
complete,
validate
command
and
then
call
run
on
that
options.
So
as
it
stands
now
now
that
we
have
all
of
our
coop
control
code
or
most
of
it
anyway
in
staging,
and
it
is
eligible
to
be
reused.
H
One
of
this.
The
slight
problems
is
that
we've
tightly
coupled
these
options
with
CLI
code
with
with
Cobra
code,
and
so,
if
you
look
at
something
like
the
apply
options
complete,
it
actually
takes
in
a
parameter
which
is
Cobra
related,
and
it
may
be
that
we
don't
want.
You
know
we're,
not
we're
not
building
a
CLI
is
so
that
might
makes
sense.
H
It
may
be
that
you,
you
know
in
your
controller,
you
want
to
create
these
options,
fill
them
in
and
then
call
run
and
and
what
I'm,
what
I'm
proposing,
and
what
I
think
that
we
may
do
some
refactorings
for
is
to
decouple
this
Cobra
code
from
the
options
so
that
these
options
are
more
pure
and
more
reusable,
and
so
the
the
PR
that
that
I
put
the
link
into
the
for
the
in
the
doc.
It
shows
an
example
of
it.
It's
a
very
you
know
pretty
simple
PR.