►
From YouTube: Config Working Group 2.08.18
A
So
before
I
start
just
just
to
give
a
bit
of
recap,
so
our
initial
plan
that
captured
in
the
clicks
top:0
the
command,
is
to
come
up
with
a
very
basic
component
in
the
system.
That's
gonna
do
little
perturbance
to
the
existing
configuration
model.
Existing
CRD
is
existing
tooling
and
just
be
a
component
on
top
until
it
can
become
like
the
v1
proper
and
the
most
interesting
thing
about
this
is
this
is
essentially
a
component.
That's
gonna
be
synchronizing.
A
Data
from
a
visible
CRT
is
essentially
our
public
API
to
an
internal
set,
and
this
approach
kind
of
allows
us
to
have
a
very
little
perturbance
in
the
existing
system,
existing
components
from
switching
to
a
galley
based
model
train
on
gearbest
based
model.
So
you
know
that's
kind
of
the
Alpha
story
we
have.
So
the
idea
is
by
the
time
east
your
v1
ships.
We
expect
Kelley
to
be
in
alpha
mode
and
it
will
be
an
alpha
feature
of
East
here.
A
A
So
there's
little
perturbance
in
the
existing
model,
existing
glide
path
of
the
system
so
and
the
basic
idea
is
based
on
a
controller
model
like
a
standard
pattern
where
we
reads
a
bunch
of
resources
from
the
API
server
like
from
cits,
and
I
kind
of
populate
in
other
sets
from
which
the
components
can
actually
read.
So
the
components
all
they
need
to
do
is
instead
of
pointing
to
one
set
of
CID
is
point
to
another
sets
partition
by
some
some
mapping
model.
A
So
the
basic
idea
is
I
actually
created
a
prototype
for
this,
and
it
is
like
a
very
raw
prototype.
I
hope
everyone
can
see
my
screen,
so
it's
checked
in
by
the
way
into
the
galley
branch.
If
you
go
to
the
gallon
branch
of
East
EO
and
go
to
the
galley
folder,
you
can
find
all
the
code
that
I'm
about
to
show
you
there
so
just
to
get
things
started.
Actually
again.
A
Takes
a
while,
and
that's
some
more
okay,
so
if
you
just
so,
these
are
the
command
line,
flags
that
I'm
using
just
to
make
sure
that
we
can
see
some
interesting
stuff
going
to
set
it
error,
like
you're
I'm
debugging,
like
looking
at
the
debugging
stuff
I
just
need
to
specify
the
config
file,
because
I
am
running
this
locally
instead
of
this
being
in
a
cluster.
So
there's
a
if
you
look
at
this
there's
a
bunch
of
available
commands
now
just
to
quickly
go
through
them
copy
doesn't
one-time
operation.
A
A
So
the
first
thing
that
we
need
to
do
is
just
initialize
the
system
which
essentially
effectively
creates
a
copy
of
the
existing
CR
DS.
So
this
is
just
gonna
go
and
pretty
much
do
that
and
if
I
knew
types
again
now,
I
can
see
both
the
public
types
as
well
as
the
internal
ones
so
and
from
here
on
I
can
actually
start
the
system
by
typing
server.
But
before
doing
that,
I
just
want
to
you
know
show
that
there's
no
trickery
here
so
I
switched
to
my
other
screen
to
use
cuticle.
A
So
in
the
east,
your
system,
I'm
just
gonna,
get
a
bunch
of
athlete,
manifests
from
the
config
iste
iĆ³
api
group
right.
So
there
is
the
easier
proxy
and
kubernetes.
So
if
I
actually
do
this
for
the
internal
one,
they're
gonna
be
empty,
so
I'm
gonna
switch
here,
I'm
gonna,
do
it
the
server
one
and
it's
gonna
start
immediately,
syncing
from
one
end
to
the
other
one
so
I'm,
just
gonna,
let
it
to
quiesce.
A
A
A
Click
that
it
has
Origin
IP,
ok,
so
let's
do
something
a
bit
different.
So
let's
actually
replace
this
with
a
let's
change
this
right.
So
instead
of
Origin
IP,
we
have
destination
IP
now
in
in
attributes
right,
so
it
says
little
change.
So
let's
do
a
little
ways
to
so.
You
have
to
write
it
correctly.
First,
ok!
So
it's
just
doing
some
reinitialize
ation.
But
if
you
notice
there's
a
modified
entry
here,
it
actually
picked
it
up.
It
was
able
to
want
to
be
fine.
Sorry,
let's
do
it
again:
it's
not
destination
IP.
A
A
C
A
C
D
C
A
So
the
one
thing
I
am
a
bit
worried
is
like
ok,
we
are
doing
this
and
any
feedback
either,
which
means
either
people
are
like
hundred
percent
on
board
with
this
idea,
which
is
great
or
they
are
not
paying
enough
attention
so
that
you
know
at
some
point
somebody's
going
to
come
up
and
say,
wait
a
minute
and
that's
really
the
lesser
thing
that
I
have
anyone
I
want.
Yes,
I.
My.
D
D
A
A
A
A
Sure,
yeah,
JC,
okay,
so
to
0-8
two
is
the
main
epic
I
am
using
to
track
work.
I
just
pasted
a
bunch
of
work
at
very
high
level
stuff
this
morning,
I
think
I'll
just
add
a
couple
of
more
so
one
of
the
first
things
that
need
to
do
is
design
the
actual
mapping
between
the
public
and
internal
see
IDs
in
this
demo.
I
have
used
the
different
API
groups,
but
there's
ongoing
work
to
actually
split.
A
This
see
ids
themselves
into
multiple
API
groups,
so
which
means
the
approach
that
I've
shown
here
is
not
gonna
actually
directly
work,
but
I
think
we
need
to
come
up
with
a
basic
like
in
mapping
algorithm
and
define
it.
And
then
you
know
the
high-level
augur.
10
applies,
it's
just
that
mean
to
figure
out
the
right
mapping
to
do
now.
So
one
of
the
other
things
is.
A
We
need
to
make
sure
that
whatever
alpha
feature
enabling
model
East
you
is
gonna
have
Gally
needs
to
be
part
of
it,
with
the
assumption
that
by
these
two
of
you
on
ships,
Yale
will
be
alpha
will
also
on
offer
in
alpha
mode
and
then
essentially,
we
need
to
implement
two
main
components
which
the
first
one
is
this
here,
D
sinking,
so
I
I,
don't
know
whether
you
have
noticed,
but
all
right,
you
know
do
not.
The
set
of
C
IDs
are
not
hardwired
in
Delhi.
A
Actually,
Gally
knows
where
to
look
to
find
all
the
CDs
in
the
system
and
then
just
essentially
copies
them
without
really
looking
in
their
contents
right
so
and
I
think
this
is,
for
the
most
part,
this
is
going
to
work.
We
need
to
make
sure
that
we
can
do
this
both
during
the
like
the
initial
deployment
of
Gally
into
an
existing
system
and
also
during
may
be
a
component
updates
very
like
CR
DS.
For
some
of
these
are
things
things
are
also
changing,
so
whatever
CID
artists,
like
the
public
API
updates,
are
happening.
A
Delhi
needs
to
be
on
top
of
it
and
make
sure
that
it
can
adapt,
and
finally,
we
also
need
to
implement
the
actual
resource
syncing.
As
you
have
seen,
there
are
certain
things
that
are
missing
here,
for
example,
it
doesn't
do
a
like.
It
doesn't
try
to
make
sure
that
those
two
sets
are
completely
equal.
It
just
listens
to
events
and
it
plies
to
events
on
the
other
side
and,
as
you've
seen
like
it,
doesn't
actually
notice
that
I
deleted
the
internal
resource
and
you
know
which
could
cause
the
problem
right.
A
So
there's
no
remediation
factor
for
these
kinds
of
problems
right
now
and
then
finally,
we
need
to
just
productionize
it
like
we
need
to
put
like
telemetry
in
this,
make
sure
that
we
are
publishing
the
right
logs.
You
know
those
go
to
the
right
place
have
documentation.
You
know
that
I
cross
the
t's,
those
kinds
of
things.