►
From YouTube: It's time to Go! Episode 3
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
Before
we
start,
please
feel
free
to
interrupt
me.
If
you
have
any
questions-
and
let's
have
a
conversation,
I
don't
want
it
to
be
just
a
presentation
and
yeah,
so
let's
just
feel
free
to
interrupt
and
before
I
delve
into
the
change
itself,
let
me
give
you
some
context
regarding
like
what
we
are
changing.
Scheduler
is
part
as
part
of
the
monitoring
stack
we
are
working
on,
which
takes
care
of
launching
other
components
of
the
monitoring
stack.
A
You
can
think
of
it
like
a
super
scheduler,
it
schedules
other
schedulers
and
because
of
that,
it
needs
to
deal
with
lots
of
different
types
of
objects,
not
limited
to
kubernetes
objects.
So,
for
example,
we
can
have
like
a
crd
from
prometheus
from
circ
manager
and
from
many
other
different
components,
so
the
current
approach
is
having
so.
The
current
approach
to
this
is
basically
translating
all
the
manifests
into
static
code.
So,
for
example,.
A
And
manifests
get
desired
extent
here
it
has
a
bunch
of
small
reconcilers
that,
in
turn,
take
care
of
creating
like
making
sure
that
the
definitions
in
kubernetes,
like
I
api,
match
the
ones
that
stem
from
the
configuration
that
we
submitted.
A
So,
for
example,
this
here
we're
having
seven
service,
monitor
objects
for
prometheus
and
we
just
create
object
using
go
using
the
go
client
for
kubernetes.
The
problem
with
this
approach
is
that
it
requires
lots
of
boilerplate,
so
you
need
to
basically
translate
all
the
manifests.
You
have
into
go
code.
Secondly,
up
maintaining.
This
is
a
problem,
because
you
need
every
time
you
bump
the
manifest.
A
You
need
to
go
for
the
go
code
and
make
sure
that
everything
work
that
everything
that
was
changed
in
app
stream,
manifest,
for
example,
for
new
version
of
prometheus
needs.
Israel
also
reflected
in
the
go
code
that
handles
it
in
scheduler,
so
that
once
we
bump
the
image
of
the
prometheus,
for
example,
the
configuration
matches
the
burden,
the
manifest
configuration
like
the
deployments
airbag
or
anything
matches
the
requirements
for
the
new
image
that
we
are
deploying
now
the
so.
A
The
new
approach
that,
in
this
pr
this,
mr
sorry,
suggests
and
we
it
are
right
on
here-
it's
using
dynamic,
client
from
kubernetes
and
the
difference
between
like
the
the
client
we
are
passing
current
like
there
are
three
different
clients
in
kubernetes
like
the
I
may
mess
up
the
naming,
but
like
the
go
client
controller,
runtime,
client
and
the
dynamic
client.
A
So
the
first
line
just
have
types
for
everything.
A
A
That
goes
that
just
drops
all
this
complexity
of
the
go
code
and
treats
all
the
manifests
uniformly,
and
this
is
basically.
A
Just
saying
yes,
yes
like,
but
there's
no,
nothing
for
free
and
yeah
and
get
desired
sites
on
synchronized
manifests,
and
this
is
basically
where
the
all
the
magic
functions.
While
the
automatic
magic
happens,
and
let
me
explain
what
are
we
doing
here?
A
A
A
So,
instead
of
like
having
like
a
bunch
of
definitions
that
we
define
that
we
have
in
the
go
code,
we
only
define
the
changes
that
need
to
go
into.
Kubernetes
manifests
depending
on
the
configuration
that
was
provided
by
the
operator.
A
So
here,
for
example,
you
have
a
customized
patches
defined
using,
and
the
parameter
here
that
we
are
probably
that
we
are
submitting
is
like,
for
example,
namespace
or
the
host
name,
where
the
cluster
for
them,
from
which
the
cluster
was
going
to
be
visible.
A
Here
we
have
like,
depending
on
the
environment,
if
it's
aws
or
simple
kind
deployment,
so
we
applying
different
patches,
creates
or
create
different
patches
depending
on
the
configuration-
and
I
will
go
back
to
this
later
so
now,
moving
forward
once
we
create
the
customized
patches,
we
use
a
crusty
library,
it's
a
very
simple
one,
because
it
allows
you
to
basically
do
what
the
customize
command
line
does
so
just
create
a
file
submit,
and
I
put
manifest
next
to
it
and
call
the
crusty
library
and
it
will
return
you
a
bunch
of
blobs
and
for
that
so
we
do
not
want
to
write
disk,
and
so
we
use
in-memory
file
system
for
that,
so
we
basically
create
customizations
and
in
memory
serialize
them
write
them
to
in-memory
file
system
and,
together
with
the
manifest
run
across
the
library
and
get
a
bunch
of
blobs
bite,
blobs
and
now
this
may
seem
inefficient,
but
from
what
I
saw
of
course
happy
to
be
educated.
A
This
that's
the
interface
that
crusty
is
providing
so
crusty
is
expects
a
file
system
with
files,
and
it
does
the
customization
on
these
files.
So
you
cannot
just
submit
like
the
static
types
to
to
or
like
blobs
directly
to
crusty.
You
need
a
file
system
for
that
from
what
I've
phoned.
I've
reformed
I
found
out,
and
so
once
we
have,
this
bunch
of
blobs
decision
comes.
So
we
are
clearing.
If
we
are
tearing
down
the
infrastructure.
A
A
We
got
from
crusty
into
kubernetes
api,
and
this
is
done
here
and,
to
be
honest,
I'm
I'm
wondering
if
this
can
be
done
better
because
it's
like
a
lots
of
dance
between
like
lots
of
conversion
between
yaml
and
byte
and
again
back
to
yaml,
but
I
was
trying
to
go
like
find
a
like
a
good
description
of
kubernetes
api.
That
could
explain
like
what
exactly
is
the
interface
here.
That
are
like
some
examples,
but
I
haven't
found
it
so
I
just
was
like
experimenting
and
hacking
until
I
got
it
working.
A
So
probably
it's
not
not
optimal,
so
yeah
and
how
it
works.
A
So
we
are
going
from
manifest.
So
manifest
is
like
a
map
of
bike
blobs
and
we
go
through
these
byte
blocks,
one
by
one
and.
A
We
create
a
new
reader,
so
a
note
here
so
single
blob
that
we
get
from
crusty
can
contain
multiple
yarn
documents
and
we
cannot
just
submit
all
these
documents
to
kubernetes
api.
We
need
to
just
separate
them
and
submit
them
one
by
one.
So
we
are
starting
a
new
yammer
decoder
that
takes
care
of
this
and
we
go
through
each
this
of
these
resources
and.
A
A
A
Once
we
have
this
unstructured
object,
we
apply
the
apply
it
like
there's.
Some
like
this
code
needs
to
be
changed,
so
I
maybe
won't
be
going
into
details
here.
Also.
A
So
the
code
for
comparison
needs
to
be
changed,
so,
as
I
mentioned
at
the
beginning,
this
is
something
we
need.
I
need
to
improve
still,
but
once
we
determine
that
the
money
that
the
object,
that
the
manifest
really
needs
to
be
applied,
we
use
server
side,
apply
to
upload
it
into
kubernetes
api.
Now
I
can
go
into
more
details
into
in
couple
of
places
or
but
but
let
me
know
if
this
is
clear
like
it
doesn't
make
sense,
do
you
have
any
like
feedback?
A
C
A
Sure-
and
I
would
be
happy
if
I
would
be
happy
to
also
explain
how
certain
components
here
work,
maybe
from
the
dynamic
client.
How
would
the
code
manifest?
Because
maybe
you
will
be
able?
Maybe
this
is
something
you
could
use
in
your
mrs
or
your
work,
so
if
that,
if
it
doesn't
make
sense
like
if
something
is
not
clear,
then
good,
then
this
is
something
we
could
talk
about
and
go
into
more
detail
and
explain.
A
So
this
is
not
about
only
about
mmr,
but
also
about
the
technologies
we
use
like
the
apis.
We
use
and
like
how
we
can
how
we
can
use
them
in
other
code
bases.
D
A
So
we
get
this,
we
get
this
block
and
then
we
create
a
new
reader
so
that
we
can
pass
part
pass
it
to
yamautil,
yam
or
json
decoder.
This
is
like
a
kubernetes
utility
that
I
found
that
can
parse
kubernetes
so
from
what
I
gather
like
the
yam.
That
kubernetes
is
using
using
is
a
bit
more
there's
some
flavor
to
it.
So
this
is
not
like
a
very
like
a
pure
yum
there's
some
like
extensions
to
it.
A
I
think
I
think
this
one
of
them
is
timestamp
related
and
there
is
also
some
extra
tooling
that
kubernetes
provides
for
yam
decoding.
So,
if
I'm,
if
I
remember
correctly-
and
this
is
one
of
these
two
links
so-
and
it
takes
care
of
like
splitting
the
documents
like
it's
reading
from
the
blob
and
spilling
out
spitting
out
individual
yam
documents
from
this
huge
blog
and
once
we
get.
A
And
it's
it's
just
like
this,
just
like
a
normal
scanner,
it
produces
these
documents
until
it
gets
into
under
10
to
the
end
of
the
file
where
its
returns
like
iof
are
on
and
now
go
here
like
it
is,
there's
a
helper
function
that
takes
care
that
works
with
a
young
or
json
decoder.
A
So
it
calls
the
decode
method,
which
basically
returns
another
object
just
like
we
would
get
with
scanner
and
again
another
util
that
I
found
in
kubernetes
tooling.
That
decodes
like
opted
like
this
raw
yam
document
into
unstructured
object
and.
A
Yeah
so,
and
the
thing
that
I'm
not
certain
here
is
that
here
we
are
decoding
here.
We
are
decoding
object
from
yaml
from
this
big
yam
of
greek
blob
using
the
decoder,
and
we
need
to
decode
it
again
here
using
the
coding
serializer.
A
So
it
sounds
to
me
as
if
we
were
decoding
the
object
twice
so
first
to
get
this
to
separate
it
from
like
the
big
so
from
the
big
document
that
contains
multiple
young
documents,
and
then
we
are
decoding
the
object
itself.
I
was
wondering
if
you
could
do
it
in
the
single
step,
but
I
haven't
found
any
documentation,
or
example
on
the
internet,
so
mikhail
doesn't
answer
your
question.
A
Now
katic
is
there
anything
like
unclear
or
anna?
Is
there
anything
clear?
I
could
like
explain
more
about
like
this
codeperson,
maybe
touring.
A
So
it's
all
about
this,
so
this
is
like
a
type
in
kubernetes
api.
Go
typing,
kubernetes
api
that
basically
moves
that,
instead
of
specifying
like
the
types
for
all
the
fields.
So
if
once
you
so,
for
example,
if
you're
decoding
yaml
or
json
in
go
you
you
are
decoding
into
struct,
and
this
track
has
types
and
tabs
and
and
what
not
and
unstructured
object
is
different,
because
it
does
not
care
about
the
types
of
individual
fields
it
co.
A
It
treats
everything
as
a
map,
string
interface
and
this
interface
can
be
another
map
or
a
slice
or
a
field
or
an
integer
of
anything.
So
we
are
basically
doing
that,
like
a
very
shallow
decoding
of
the
kubernetes
object
into
this
unstructured
type
and
kubernetes
has
some
like
a
very
like,
and
this
unstructured
type
provides
some
of
like
a
basic
methods
for
you
that
enable
you
to
work
with
this
object
all
together.
A
So,
for
example,
group
object,
kind
group
object
resource
and
which
are
used
when
support
submitting
object
to
kubernetes
api,
but
that's
about
it.
You
can,
if
you
like,
if
you
want
to
address
individual
fields,
you
need
to
use
just
a
second.
Let
me
set
nested
slice.
Things
like,
for
example,
set
nested
slides,
so
they
are
setters
and
getters
for
all
the
kind
of
kinds
of
fields
that
unstructured
object
has.
A
A
E
I
think
I
missed
where
we
got
the
manifest
blob
and
why
is
it
multiple
blobs
of
multiple
files.
A
So
controllers,
let
me
find
it
first
manifest.
A
So,
first
of
all,.
A
A
Human
letters
applications
provide
you
with
a
manifests
that
define
how
the
service
needs
to
be
deployed,
and
this
manifests
is
a
bunch
of
young
documents
so,
for
example
like
we
have
here,
and
they
defined
apart
from
the
deployment
itself,
so
how
the
program
is
actually
running
on
the
kubernetes
cluster.
It
also
defines
like
what
are
its
permissions.
A
What
are
its
service
accounts?
What
are
what
we
have
also
here
deployment
role,
building
so
yeah.
So
all
the
things
that
are
like
together
make
this
component
work,
so
we
have
multiple
young
documents
that
are
working
in
concert
to
make
like
a
component
behave.
A
The
way
we
want,
and
as
I
was
describing
before
like
there
are
multiple
that
so
referring
back
to
what
I
said
before
so
there
are
like
single
yam
document
can
have
a
multi
single
yam
blob
can
have
multiple
documents,
so
this
stems
from
the
fact
that
we,
the
yam
or
json
parser
tool
that
I
was
showing
earlier,
takes
this
block
that
we
downloaded
for
to
the
for
the
given
application
and
splits
them.
So
this
is
like
a
yam
separator
here
and
every
docu.
A
Every
yam
document
between
these
separators
is
a
separate
document,
so
we
are
going
one
by
one.
So
first,
this
one
is
parsed
and
not
more,
then
this
one
is
parsed
and
parsing
stops
here
before
the
next
document
separator.
So
we
have
multiple
documents
in
a
single
file.
Now,
having
said
that,
going
back
to
how
this
work,
how
we
got
here.
A
Cluster
control
over
just
a
second
deployment
s
now
we
use
go
embed
to
store
these
blobs
in
the
binary
and
then.
A
A
Then
we
store
them
in
the
map,
the
in
the
map
of
blobs,
so
every
component
has
its
own
name,
and
the
value
for
the
from
the
entry
in
this
map
is
like
a
yummy
manifest
with
all
these
changes,
as
once
we
have
it
at
all.
These
changes
for
our
we
unmanifest
with
all
the
configuration
of
the
given
component
and
once
we
have
it.
A
A
Use
crusty
and
crusty.
So
basically
what
we
are
doing
here,
we
are
creating
a
temporary
memory
of
in-memory
fi
system
using
like
firesys
library
in
go
and
yeah.
So
this
is
like
not
very
efficient,
but
again,
something
probably
that
could
be
improved.
We
marshal
this
manifest
that
we
got
and
write
them
to
a
file
in
this
in
memory
file
system,
write
a
customization
and
run
a
customizer,
so
maybe-
or
maybe
I
should
have
also
like
explained
like
so
do
you
do?
A
A
Okay,
so
we
use
customizer
library
from
crusty
and
it
basically
expects
a
file
system
and
a
path
where
the
customization
is
and
it
does
what
the
tool
command
line
tool
does
but
programmatically.
So
it's
like
a
pretty
high
level
api,
but
it's
pretty
simple.
I
cannot
say
that
I
don't
like
it
and
so
customize,
customize,
customizer
or
recrusty
returns
a
resource
map
which
is
basically
some
metadata
and
a
bunch
of
yammers
which
is
okay
to
know
just
a
moment,
yeah
which
can
be
good
here,
which
we
got
here
so
basically.
A
So,
okay,
I
would
have
to
look
for
the
definition
of
this
interface,
but
asean
returns
a
bunch
of
blobs
that
are
basically
plot
parsed
in
manifest
after
customers,
custom
after
custom
customize
did
it
thing,
and
this
is
where
we
got
the
blobs
in
the
first
place.
Does
it
answer
your
question?
Is
it
clearer
now.
A
So
do
you
have
any
other
questions
or
how
suggestions
how
we
can
improve
it?
I
I.
D
B
I
have
a
suggestion
of
how
you
can
improve
it,
so
I
had
to
do
this
exact
thing,
basically
without
customize,
though
some
time
ago,
when
I
was
working
on
the
agent
initially
and.
B
I
also
stumbled
upon
this
yama
framer,
like
the
thing
that
chunks
the
globe
into
separate
camels
and
then
serializer
and
then
eventually
I
asked
myself.
How
does
cuba
city
would
do
it
and
then
they
went
and
looked
and
then
yeah.
B
A
A
B
B
B
So
if
you
have
a
custom
resource
definition
in
the
crd-
and
you
don't
have
that
crg
in
the
cluster,
yet
then,
if
you
use
chip
ctl
today,
you
cannot
apply
those
two
objects
together.
Cuba
city
will
blow
up
saying
that
I
don't
know
this
resource
kind
so
and
there
is
a
bug
about
it
in
the
backtracker
notice,
so
select
use,
which
is
what
kpt
uses.
Has
this
helper
function,
which
I
wrote
it
myself
before
I
found
it.
B
Somewhere
here
yeah,
and
then
you
can
just
it
understands
if
you
have
a
custom
resource
over
customer
service
definition
and
whether
it
needs
to
set
the
name
space
on
that
object
or
not.
All
of
that
is
to
just
set
the
namespace
for
the
namespaced
objects.
B
And
then-
and
then
I
I
think
in
our
previous
conversation,
I
suggested
to
use
solidity
or
stop
light
objects,
and
I
still
recommend
you
to
have
a
look,
and
this
is
what
it
would.
It
would
look
like.
B
This
is
the
applier
that,
like
instance,
of
that
library,
basically
you
give
it
a
bunch
of
objects,
and
you
give
it
information
about
the
inventory,
and
it
applies
all
that
stuff
to
the
cluster.
Also
deleting
the
things
that
should
be
deleted,
because
your
source
manifests
no
longer
have
held
them.
A
A
So
this
is
like
a
don't
go
like
back
or
feature
like
at
this
point,
I'm
not
sure
which
what
exactly
have
a
look
at
this
link.
A
So
this
is
like
a
a
bit
unexpected
behavior
when
parsing,
when
this,
when
d
serializing
json
objects
in
go
and
if
you
haven't
had
a
chance
to
run
into
it
yet
so
the
the
gist
of
it
is
that
go
does
not
reset
the
field
that
like
like.
If
we
are
deserializing
into
an
object,
it
doesn't
get
zeroed.
A
And
you
will
get
like
an
amalgam
of
the
two,
and
this
is
pretty
unexpected,
because
when
basically
like
the
behavior
in
the
different
parts
of
go,
you
would
expect
that
object
gets
zeroed
or,
for
example,
sliced
slices
get
shrunk
and
then
only
expanded
and
obviously
and
elements
added.
So
I
highly
recommend
having
a
look
at
this
bug,
so
maybe
you
will
find
it
useful
if
you
haven't
already,
if
you
haven't,
had
a
chance
to
look
at
it
yet
so
and
that's
basically
all
I
have
to
have
for
today.
B
D
A
Yeah,
so
for
for
the
sake
of
anybody
who's
watching
this
video,
let
me
know
if
you
have
any
other
topics
or
any
other
questions.
If
not,
then
maybe
let's
stop
recording
and
conclude
for
now.