►
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
A
B
Arthur
I
I
believe
you
started
working
on
some
of
some
of
it.
Do
you
have
any
any
initial
thoughts
because
for
me,
I
can
start
actually
I
believe
we
should
store
them
as
Hamel
files.
So
the
similar
s
we
store
things
for
kubernetes,
then
we
buy
by
design.
We
have
already
history
who
changed
what
and
that's
a
good
thing
actually
to
do.
Have
it
and
we
can
schedule
a
pipeline
and
you
can
run
it.
C
Yeah
I
started
kind
of
working,
but
I
feel
like
the
stuff
I'm
doing
right
now
is
not
my
might
not
be
relevant
for
this
particular
discussion
because
I'm
doing
things
specifically
what,
if
knowledge
it's,
not
generic
and
I
decided
to
go
to
bypass
the
step.
That
Sam
is
interested
in
is
how
do
you
code,
someone
here,
capture
Pro
like
magic,
West,
widget
or
something
Rotom.
C
A
A
I
mean
I,
guess
just
to
clarify,
like
I
really
need
this
discussion,
you
know
I
know
we're
doing
one
thing
for
the
short
term,
but
I
really
so
I
could
be
useful
for
us
to
find
the
architecture
you
know,
for
the
end
state
and
and
in
the
long
term
and
say
I
was
just
a
bunch
of
requirements
up
top
here.
Look
how
much
we're
between
the
one
you
know
to
take
the
policy
management.
A
Why
they're
working
on
now
are
there
and
in
feeling
the
right
now
we're
serving
with
Fillion
Paul
page
with
Limbaugh
would
add
in
you
know,
lots
of
other
kinds
of
policies
and
and
a
teacher
and
make
it
accessible,
and
you
know,
address
the
user
requirements
here
in
that
policy
management
current.
And
so
you
know
what
do
that
and
state
architecture?
Look
like
understanding
the
we're.
C
C
Yeah
yeah
get
back,
I
guess
plan
discuss
right
now,
right
at
the
star,
I,
don't
know,
I
I
see
the
benefits
of
doing
either
way
and
the
only
thing
that
is
my
mind
gone
with
llamó
files.
Just
it's
an
indirect
way
of
doing
things
right
now
and
will
make
us
to
more
to
deploy
policy
and
automatically.
It
comes
with
the
dependency
of
CI
by
point
most
likely,
which
might
be
a
good
thing
in
some
cases.
C
D
Sometimes
you
get
up
into
pretty
high
levels
of
either
security
or
engineering
management
and
if
you
have
them
in
a
yamo
file
in
a
repo,
if
the
only
people
that
can
approve
em
ours
on
that
repo,
are
your
upper-level
management.
You
could
get
into
even
more
issues
with
trying
to
have
maintain
errs
on
that
repo
actually
maintain
the
repo,
because
you
you
wouldn't
have
enough
maintainer
x'
to
cover
all
of
the
the
actual
development
that's
going
on
just
so.
You
could
lock
down
these
policies.
C
Again,
my
opinion
is
that
llamo
file,
it's
just
additional
steps
that
we
have
to
take
care
of,
and
there
is
no
like
cuba.
Nets
itself
does
not
have
a
necessity
for
llamo.
Llamo
is
just
fart
format
that
format
that
is
conveniently
used
right
now
for
the
kubernetes,
but
under
the
hood
it
stalls,
typed
information
in
each
city,
right
so
I
would
say
strong
necessity
to
do
kubernetes
to
go
with
Gama
file.
Sorry
and
I
don't
see
it
right
now.
C
That's
probably
why
I
don't
see
much
value
in
that,
and
on
top
of
that,
the
way
we
deploy
in
policy
right
now
and
we
can
deploy
policy
right
now,
because
we
have
direct
access
to
that
question.
It
makes
llamo
file
even
more
redundant
because
we
can
go
just
install
any
information
that
you
use
your
bill
type
to
us
into
the
cost,
bypassing
yeah
more
completely.
So
that's
just
what
I
see
right
now.
E
So
for
leapin
and
Alan
Philippe,
maybe
you
had
a
really
good
point
on
some
of
the
requirements
that
that
we
get
for
free
using
Emma
files.
F
A
move
house:
how
could
we
know
first
of
all,
I'm
not
sure
that
we're
going
to
define
any
network
police
at
the
group
level?
That
doesn't
mean
anything
to
me.
That
would
be
super
weird
super
dangerous
and
secondly,
if
we
don't
use
a
fine,
if
we
put
things
in
the
DBE
meaning
we
need
the
UI
for
that
we're
going
to
prevent
it,
because
we
need
to
figure
out
who
is
going
to
be
able
to
do
what?
F
Who
did
what?
So
we
need
traceability.
There
is
no
way
to
audit
that
we
have
that
program,
for
example
with
the
dismiss
or
you
know
no
exactly
know
where
that,
because
we
have
the
DoD
trace,
but
it's
a
lot
of
redundancy
with
everything
that
were
already
having
at
the
repo
level.
If
we
have
code
honors
fines,
we
could
require
the
approval
of
some
people
in
the
team
to
approve
any
changing
this
network
policy
file,
for
example,
which
is
something
that
we
don't
have
in
the
UI
that
we
would
need
to
redevelop
again
Tony
from
scratch.
F
G
G
G
C
One
grass
level
this
one
of
the
options
for
us
to
sterilize
data
generically,
but
at
the
same
time
you
have
to
think
of
the
time
that
all
the
policies
that
cabinets
defines
a
statically
type-
they
have
a
schema
by
itself
and
when
kubernetes
this
arises
policies
from
your
Yahoo.
It's
actually
does
that
against
the
schema.
So
we
definitely
can
put
this
information
into
that
base
and
even
generically
using
polymorphic
relationships,
for
example,.
A
Well,
if
we're
not
getting
too
much
room
where
the
conversations
gone,
police
I
want
them
to
come
back
to
your
comments
about
network
policies
at
the
group
level
and
just
clarify
that
use
case
a
little
bit
really
the
use
case
there
at
the
instance
and
group
and
project
levels.
It
still
is
going
to
be
applied
at
the
environment
level
because
that's
where
network
policies
can
be
applied,
but
if
you're
able
to
manage
policies
at
the
group
level
that
will
save
you
the
need
to
duplicate
policies
across
all
of
your
different
environments.
A
In
the
case
that
you
have
one
policy
that
you
want
to
apply
to
everything
inside
of
a
group,
so
the
thinking
is,
you
would
create
that
at
a
group
level
that
would
just
flow
down
and
be
a
required
policy.
That's
included
for
all
environments
in
all
projects
that
belong
to
that
group.
So
it's
not.
You
know
there
is
no
environment
at
the
group
level,
but
you
could
still
create
a
policy
it
could
bubble
and
have
that
flow.
You
know
flow
down.
F
I'm
really
interested
it's
something,
but
that
we
could
do
also
with
you
in
Yemen
five
scientists,
so
I
added
another
example.
If
you
have
a
change
in
the
network
Priscilla,
you
don't
want
an
application
to
hit
a
certain
port
directly,
and
that
requires
to
update
the
application,
because
the
traffic
is
going
through
another
toad
or
something.
How
do
you
think
that
if
you're
don't
have
a
file,
that
means
you
will
have
to
change
your
application
and
click
on
the
UI
deployed
button?
F
C
Think
the
process
is
slightly
different
for
all
cabinets
policies,
because
they're
deterministic
in
terms
of
how
they
apply
and
is
they
work
on
names
based
on
combination
of
namespace
in
the
label?
You
can
actually
put
predictable
policy
ahead
of
time
before
the
point
application.
If
you
know
the
label
and
namespace
and
because
you're
in
control
of
the
label
in
with
namespace,
you
definitely
can
put
any
kind
of
given
its
policy
and
I'm
talking
point
security
policy
and
it
work
policy
ahead
of
time.
H
So
one
of
the
questions
and
I
think
downsides
that
I
see
to
the
mo
file
is
I.
Don't
know
how
you
query
a
bunch
of
projects,
so
if
you're
trying
to
enforce
a
particular
policy-
and
you
want
to
say-
hey-
which
am
I-
which
of
my
projects
are
in
compliance
with
this,
if
it's
in
the
yeah
mo
file,
that
is
a
massive
undertaking
to
try
to
go
into
each
project.
Read
the
repo
grab
the
mo
file
parse
it
as
opposed
to
a
database
query,
which
makes
something
like
that
or
enforcing
policies,
significantly
easier.
C
Yeah,
just
was
thinking
about
that
when
the
Mayor
was
talking
about
database
and
just
what's
the
track
of
it.
Thanks
for
incident,
yeah
I
think
it's
really
valid.
It's
definitely
if
it
will
be
doing
more
advanced
operations
and
policies
like
let's
say
copy
or
tempo
18,
or
something
like
that,
going
back
and
check.
Yamo
files
will
go
almost
impossible
in
certain
situations.
It's
just
too
much
it.
It's
real,
slow
down
the
UI
right,
it's
not
going
to
be
real
time
and
that's
the
advantage
of
having
a
database.
G
The
you
sorry,
you
go
it's
just
that
when
I
did
the
plus
one
I
wrote
it
exactly
like
that.
I
said
that
if
we
are
not
needing
to
query
within
the
policies,
then
yeah
they're
no
firewood
would
cover
that.
But
if
we
are
looking
towards
having
a
monitoring
of
each
field
for
the
policies,
then
EML
file
would
be
harder
for
sure.
H
So
the
I
one
of
the
other
I
think
benefits
that
we
were
talking
about
for
a
llamo
file
is
just
the
audibility
of
the
mo
file
right.
It's
in
your
that's
in
your
repo.
You
can
see
who
changed
it
and
if
you
put
it
in
a
web
interface,
we
have
to
build
that
ability
in
manually
by
you
know,
throwing
it
into
the
action
the
other
tabs.
The
one
thing
that
I
will
say
is
not
everything
in
git
lab
is
audited,
and
we
may
think
that
this
needs
to
be
on
did.
H
But
what
I
will
say
is
today
not
everything
is
audited.
So
I
don't
know
if
that
has
to
be
a
requirement.
So,
for
example,
if
I
go
into
the
container
registry
today
and
hit
delete
on
a
container
that
doesn't
get
audited
anywhere
if
I
go
into
settings
of
my
repo
or
any
of
my
projects
and
change
any
of
those
settings,
those
don't
all
get
out
of
it.
H
So
if
we
were
to
move
things
to
a
web
interface,
where
things
can
be
changed,
if
you
have
permission,
but
those
aren't
all
tracked,
it
still
follows
from
the
design
patterns
of
gitlab
I'm,
not
saying
that's.
The
best
thing
to
do.
I
think
every
action
and
in
every
interface
and
get
labs
should
probably
be
audited,
but
we
would
not
be
the
only
web,
the
only
web
interface
it
doesn't
have
full
auditing
and
tracking
on
its.
A
Sure,
but
auditing
would
definitely
be
a
requirement
for
these
actions
because
you're
talking
about
actually
changing
security
policies,
that's
hiding
because
you
know
our
competitor
products
as
well,
so
we
would,
you
know
if
we
didn't
get
it
for
free,
we
would
have
to
build
it.
We'd
have
to
add
and
not
auditing
in
some
way.
H
A
Yeah
I
mean
the
end
state
for
auditing
is
more
than
just
auditing
it
you
know.
Ideally,
you
would
actually
be
able
to
go
in
and
see
the
version
history
for
the
policy
see
who
changed.
What
and
optionally
revert
to
a
previous
version.
So
you
could
go
and
say:
okay,
you
know
at
11
a.m.
Sam
white
went
and
made
a
change
that
crashed
the
production
site.
D
Right
and
that's
the
level
of
detail
that
I
have
not
gone
into
on,
because
I
don't
feel
like
it's
necessary
for
the
initial
rollout
of
what
our
auditing
would
need
to
look
like.
It
sounds
like
a
great
feature,
but
I
can
see
how
that
would
be
much
more
important
for
your
area.
So
that's
a
good
point.
The.
H
Other
thing-
and
we
haven't
kind
of
gotten
into
this
yet
is
there-
may
be
some
hybrid
solutions
right
so
that
there's
potential
that
and
I'm
just
kind
of
thinking
through
this
it
goes
into
the
data
base,
but
version
gets
stored
as
the
yamo
or
maybe
you
know
you
do
the
merge
request
and
then,
when
it
gets
merge
into
the
master
branch
it
gets
parsed
and
thrown
into
the
database
things
of
that
sort.
So
there
may
be
kind
of
some
combinations
that
they
could
get
around
so
many
shortcomings,
one
way
or
the
other
yeah.
E
A
Guard
list
of
this
engineering
decision
on
the
backend
I
mean
currently,
but
what
I've
been
discussing
with
Andy
is
a
plan
to
have
both.
You
know
easy
to
use
rules,
editor,
UI,
that
that
you
know
I
previewed
at
an
earlier
meeting.
You
know
side
by
side
with
a
text-based
editor
to
edit
the
policy
directly.
A
Now
whether
that
policy
is
a
ya
know,
file
that
gets
committed
to
the
repo
or
whether
that's
a
policy,
that's
being
pushed
directly
into
say
cilium,
you
know
again,
like
I,
think
it
could
go
either
way
on
the
back
end
and
still
accommodate
the
UI,
so
the
I,
but
the
idea
is
to
be
able
to
edit
either
the
rule
directly
or
the
with
a
UI
widget,
and
those
two
would
be
able
to
be
synchronized
together.
So
long
term
vision.
E
H
That
might
be
important
to
think
about
too
is
if
we
had
a
web
interface,
presumably
to
make
that
web
interface
work.
We'd
have
API
endpoints,
so
customers
could
actually
call
those
API,
endpoints
and
say
add,
rule
delete,
rule
whatever,
and
that
might
be
one
way
of
interfacing.
If
you
go
down
the
Yambol
route,
the
way
customers
would
really
interface
is
like
hey
here's,
my
entire
file,
you
know,
take
it
or
leave
it.
Can
they
have
to
send
everything
over
so
they
can't
do
things
programmatically
quite
the
same
way
as
if
we
had
a
web
interface.
C
I
said
it
happened
multiple
times
but
and
I
had
the
other
groups
were
having
the
single
discussion
specifically
configure
in
relation
to
cost
management,
but
it
never
actually
went
through
for
some
reason
you
know
the
assistances,
so
I
guess
the
downside
of
side-by-side
is
just
kind
of
duplication
of
work.
We
already
provide
the
bottom.
Why,
like,
let's
say
here's
a
friendly
UI?
C
G
The
thing
is
that
I'm
hearing
from
self
that
really
reminds
me
of
the
armor
policies
that,
at
our
course
is
not
going
to
be
like
a
kubernetes.
It's
going
to
be
basically
just
a
file
format,
see
file,
and
that
would
be
like
it
would
allow
if
the
user
could
just
add
that
in
you
I
understand
that
how
that
would
be
beneficial
for
the
user
instead
of
just
clicking
the
checkbox.
You
cannot
do
that
with
checkbox
for
exam.
So
then
I
see
what
self
is
coming
from.
B
Some
also
I,
remember
one
of
the
requirements
was
that
at
some
point,
we're
gonna
export
those
policies
and
you'll
be
able
to
import
them
into
different
different
projects
or
group.
So
so
that's
one
pro
for
free
mo
file
because
and
easily
exportable,
and
then
you
can
import
them
and
you
can
share
them
using
some
kind
of
like
shirt,
space
and
the
documentation
of
who
you're
like
examples
of
the
policies
that
you
could
use.
C
My
proposition
available
is
to
investigate
llamó
files.
Probably
is
the
first
attempt
and
try
how
they
fit
in,
but
I
suspect
that
database
will
be
slightly
more
convenient
straight
away.
So
maybe
we
don't
even
need
kinda
two
decision
right
now
right.
It's
it's
not
hard
to
experiment
a
bit,
but
I
definitely
feel
like
that.
Base
will
be
a
bit
easier
first
step
for
us
right
now.
Yeah.
E
B
Yeah
EML
files
anyway,
like
we,
you
don't
want
to
start
with
you
why
we
want
to
start
with
something
on
the
backhand
side.
So
that's
one
approach.
The
second
one
would
be
just
to
build
some
breasts
or
graphical
api's
for
it.
So
we
can.
We
can
do
it
with
the
amyl
files
and
then
then
see
if
we
can
deliver
it
or
not,
and
then
look
for
other
options.
C
I
guess
I'll
try
to
answer
from
my
understanding,
semeth
correct
me,
so
the
idea
is
to
have
UI,
but
because
they
will
be
sitting
in
a
repository
as
I
understand.
Right
now,
right
like
we
could
probably
work
with
Zed
and
by
that
I
mean
there
is
already
support
in
web
ID,
at
least
so
we
can
expand
that
by
D,
for
example,
just
to
provide
a
bit
feedback,
or
maybe
some
guidance
inside
the
web
interface
ID
right.
C
That's
one
of
the
options
we
discussed
previously,
so
there
are
definitely
benefits
of
VMO
file
because
it's
a
part
of
a
plethora
and
gives
some
additional
tools
access
to
some
additional
tools
that
we
are
not
using
as
much
but
I
think
they
want
and
I'm
talking
about.
If
ID
yeah
there
are
opportunities
of
that
I
feel
like.
B
Yeah,
my
idea
initially
was
to
have
something
similar
to
the
cluster
management
project.
So
so
you
have
a
repository
where
you
keep
those
siamo
files
and
then
you
can
select
for
a
cluster
that
you
would
like
to
use
this
policy
management
project
from
from
this
project,
and
you
could
set
that
on
project
true,
for
instance,
level
as
well,
and
then
you
can
modify
it
using
web
IDE
and
of
course
we
can
extend
it.
So
so
that
was
just
do
something
similar
as
as
we're
doing
already
for
for
the
management
project.
C
C
All
the
time
so
is
this:
Fink
have
to
be
really
well
thought
out,
because
we
can
mess
up
an
install
policy
into
classes
that
use
it
does
not
expect
to
install
it
and
yeah
I
haven't
won
a
repository.
Managing
multiple
Kostis
is
a
possibility,
and
it's
probably
the
way
we
wanted
to
go,
but
at
the
same
time,
I
think
putting
Oasis
inside
the
project.
Repository
will
be
a
bad
idea
because
it
gives
us
a
better
understanding
of
when
and
what
to
deploy
to
so
yet
they
depend
on
sorry
for
humbling.
C
H
So
if
I'm
hearing
correctly,
when
you
have
the
policies
in
in
Leggett
in
the
repository
they
start
to
get
applied
to
the
cluster,
which
means
we
still
don't-
have
the
full
auditing
that
we're
really
trying
to
get
to
right,
because
you
can
make
a
policy
change
and
do
all
these
things.
You
submit
the
yamo
file,
but
it
never
gets
applied.
So
you
don't
really
know
when
those
policies
are
into
effect,
which
is
part
of
what
we're
trying
to
solve
to
clarify,
because.
C
Ellen
was
specifically
mentioning
management
policy
as
a
management
project
as
a
direction.
So
management
project
is
a
separate
repository
off
your
application,
where
you
store
specifically
ammo
file
and
it
the
specific
mo
file,
is
used
to
provision
your
question
but
to
link
those
together.
You
call
into
the
cluster
settings
and
you
select
the
repositories
that
you
want
to
manage
this
question
and
because
of
that,
multiple
causes
cancelling
the
same
project.
C
And
then
here
your
statement
is
absolutely
correct,
because
changing
says
management
specifically
repository
is
doesn't
like
in
in
many
cases
represent
the
state
of
application,
but
another
option
in
registration
is
kind
of
doing
both
things
at
the
same
time.
So
we
can
investigate
boss
to
is
to
store
the
llamo
file
inside
the
project
repository
specifically
not
some
external
repository,
but
the
project
that
you're
working
on
and-
and
this
actually
simplifies
certain
things
a
bit,
because
project
only
has
usually
one
to
one
connection
to
the
quest
it's
being
deployed
to
it
depends
on
environment.
C
So,
in
this
situation,
yeah
there
is
a
better
audience
auditing
capabilities
and
a
bit
easier
to
figure
out
where
to
put
policies.
But
the
downside
is
it's
really
hard
to
support,
like
we
discussed
instance
level
policies,
group
level,
policies,
etc.
It's
a
bit
hard
to
imagine.
How
would
those
policies
apply
on
the
project
level
right
and
if
all
our
policies,
just
inside
the
repository
so
yeah
I,
don't
really
have
a
good
answer.
It's
something
that
has
to
be
investigated.
E
I
mean
the
the
the
whole
the
whole
cluster
management
project.
I
think
already
needs
shouldn't,
really
stop.
What's
going
from
from
either
way,
cuz
I
think
it's
already
a
problem
that
needs
to
be
solved.
It's
a
it's
tripped
up.
Tripped
me
up
big-time
and,
as
Arthur
was
saying,
it's
already
got
some
problems
in
there
in
parsing
and
understanding
how
you
can
apply
that
maybe
an
outcome
of
this
is
is
somebody
picks
up
an
issue
to
to
go
play
with
it
and
bring
bring
some
ideas
to
the
table.
What
does
everyone
think
a
couple
nodding.
A
Heads
so
I,
don't
know
if
that
can
be
tied
in.
We
already
have
an
issue
out
there.
I
think
Philippe
is
assigned
to
it
to
look
at
how
we
can
remove
our
hearts
our
dependency
on
Auto
DevOps
I,
wonder
if
we
can
just
extend
that
one
to
include
the
spike
that
you're
talking
about
or
if
you
want
to
have
a
separate
issue.
E
G
I
have
a
question
kind
of
related
to
this
another
artwork.
It
already
with
the
network
policy
and
I'm
working
with
the
port
security
policy
and
at
our
policies,
are
we
going
to
halt
them
a
little
bit
before
we
make
these
decisions
or
we
are
going
to
move
forward
kind
of
a
little
bit
a
dock
on
them
and
then
putting
them
together
later
on
good
question.
G
B
I
I
believe
we're
doing
something
similar
with
Falco
that
you
need
to
have
some
way
to
provide
those.
You
don't
have
policies,
but
you
do
have
like
configurations
like
alerts
or
rules
and
macros,
and
we
allow
users
to
to
modify
it
using
like
just
Falco,
schema
and
I
believe
this
will
be
the
same
like
we
cannot
force
users
to
use
the
pod
security.
I
mean
the
policy
management.
A
Yeah
I
guess
that
goes
down
too
number
four
there
of.
How
do
we
keep
everything
in
sync?
Where
you
know,
we've
got
something
in
the
database
and
or
something
in
a
yamo
file,
and
then
you
also
have
you
know
a
configuration
in
a
cluster
that
can
be
changed.
You
know,
how
do
you
have
you
reconcile
because
they
can
be
editing
things
anywhere
and
you
need
those
changes
to
be
replicated
to
all
the
places
where
the
policy
is
stored.
A
A
You
I,
don't
have
an
answer.
I,
don't
know,
I
mean
my
best.
You
know.
If
I
put
my
my
engineering
hat
on
I
would
say
my
best
thought
is
to
to
create
some
sort
of
hash
of
the
policy,
and
you
know
have
some
sort
of
precedent.
You
know
for
one
that
overwrites
the
other
when
you
see
a
disc
between
the
two
or
perhaps
you
just
create
a
new
one.
You
know
you'd
have
to
have
some
sort
of
rules
there,
but
I
don't
pretend
to
have
any
sort
of
answers
heard
answers
there.
G
H
H
One
of
the
things
about
the
hybrid
that
may
be
worth
looking
into
is,
if
you
look
at
gitlab
CIA
mole
today,
there's
actually
point
in
time
where
they
get
that
gets
parsed
into
the
database
and
I.
Don't
know
exactly
when
that
is
whether
it's
on
a
on
a
commit,
but
you
can
look
and
you
can
find
parts
of
your
yam,
your
CI
mo
file
in
the
database,
and
so
that
might
be
similar
they're
like
what
we
were
talking
about
before.
E
A
I'm
comfortable
with
where
we're
going
here,
you
know,
even
if
we
don't
get
through
everything
in
this
one
hour,
that's
ok!
You
can
schedule
more
time
later
or
continue.
The
discussion
I
would
be
surprised
if
we
actually
resolved
everything
here
in
this
meeting,
so
I
just
wanted
to
get
the
conversation
started.
I'm
sure
this
is
one
of
many
to
come.
B
You
yeah
we're
talking
about
keeping
everything
in
sync
and
I.
I
believe,
like
synchronization,
is
actually
one
of
the
biggest
engineering
problems,
always
all
the
time
so
I.
What
I
would
say
is
let's
keep
for
now.
The
policy
that
that
you
have
created
using
this
policy
management
feature
as
a
desired
State
at
it.
B
Of
course,
under
the
hood,
its
urban
areas,
it's
silly
amal
file
that
or
something
like
like
that,
it's
being
updated,
but
but
you
don't
get
that
back
to
your
repository,
where
you
originally
have
your
your
state
for
a
class
or
for
desired
state,
so
I
would
I
would
keep
that
first
release.
Definitely
something
like
that,
because
that'll
be
hard,
we
will
have
so
many
tools
and
doing
like
synchronization
translations
from
them
to
to
our
policy
management
format
will
be
definitely
something
very
challenging.
C
Thanks
for
being
didn't,
we
actually
had
this
discussion
with
salmon
network
policies
and
we
actually
decided
to
go
on
a
first
release
in
completely
different
way
and
working
directly
with
quest
for
the
same
reason
because
vein,
security
field
and
it's
nice
to
hit
just
our
policies
somewhere
and
assume
that
those
policies
are
quite.
But
all
the
directions
feel
mitigated
today
and
I'm
in
data
base
in
Yahoo.
They
have
a
critical
for
is
that
I
can
just
call
and
remove
your
policy,
and
you
will
not
be
able
to
me
in
any
way.
C
So
what
we
are
doing
with
network
policies
right
now
is
actually
working
directly
with
the
class,
because,
given
its
itself
is
he
can
store
metadata
in
etcd
and
it's
and
it
has
a
schema.
So
they
essentially
write
in
policies
from
the
Casta
and
updating
policies
directly
in
the
cluster
and
yeah.
The
value
of
that
is
that
if
someone
will
go
and
change
from
the
common
wine,
the
policy
updates
deletes
or
anything
to
be
reflected
straight
away
in
the
UI,
and
it
will
be
noticeable.
C
It
doesn't
give
like
alerting
in
any
way,
so
you
have
to
go
and
see
it
for
yourself,
but
at
least
it
represent
the
actual
state
of
the
cluster
with
the
database
and
llamó.
We
would
need
something
that
enforcing
constantly
the
state
of
it.
One
of
the
directions
that
it
that
his
orchestration
team
is
gone
right
now
is
introduced
in
github
agent
to
the
cluster,
so
we
could
leverage
that
I'm
going
to
work
for
synchronizing.
Well
until
that
is
done,
we
probably
will
be
hoping
that
our
UI
is
representing
the
state
of
the
question.
C
Depends
it
still
can
be
approved,
like
someone
creates
a
policy,
it
does
not
necessarily
have
to
be
apply
straight
away
right.
We
can
figure
out,
it
can
be
a
temporary
database
storage
for
the
magic
ways.
Specifically,
let's
say
I,
don't
know
the
capabilities
we
have
out
there,
but
maybe
there
is
a
way
to
supply
metadata
like
let's
say
it
can
be
in
description
straight
away
and
when
you're
applying
the
policy,
it
can
be
parsed
from
the
description
of.
C
I
have
not
thought
about
much
about
the
specific
fall,
because
we
don't
have
it
and
we
did
not
discuss
it
before,
but
I
see
some
ways
to
implement
to
step
up
Robo,
even
not
having
any
kind
of
database,
because
yeah
we
can
just
use
any
of
those
right.
Probably
database
can
be
easily
used
to
the
temporary
storage.
E
E
You
you
so
given
that
we
have
given
that
we
have
some
some
things
in
progress,
that
we'll
need
some
storage.
How
about
we
independent
at
least
make
it
clear
and
transparent?
What
are
we
planning
to
address
those
if
we're
not
gonna
change
the
direction?
I
think
the
least
we
can
do
is
put
it
up
somewhere
and
so
Seth
and
the
rest
is
a
huge
team.
Lilies
can
have
a
look
and
call
out.
G
Go
ahead
premiere
we
can
run
that
solution
against
use
case.
That
stuff
is
going
to
share
with
us
and
see
if
we
can
preempts
cases
that
we
should,
we
didn't
consider
basically.
A
E
E
E
A
D
A
A
I
guess,
since
it's
quiet-
and
you
know
it's
got
a
little
bit
of
extra
time,
do
you
want
to
just
call
out
one?
You
know
note
a
requirement
that
we
haven't
really
discussed
much
and
if
you
look
at
the
top
of
the
document
in
the
use
cases,
I
gave
a
couple
of
examples
of
policies
that
might
potentially
span
multiple
technologies.
A
So
you
know
I
understand
that
starts
to
become
a
little
bit
complex,
but
potentially
we
would
want
to
let
users
create
policies.
Yes,
really.
A
policy
is
a
big
if
this
than
that
statement
right
if
you've
ever
used.
If
this
on
that
and
that's
sort
of
what
we're
going
for
here,
you
know
where
you
can
have
multiple
rules
chained
together
with
ands
and
ORS.
Multiple
actions
that
are
chained
together
with
ands
and
those
actions
or
those
rules
may
not
all
come
from
the
same
technology
right.
A
So
it
may
be
the
case
that
I
see
it
action
and
you
know
something
occurs
in
Monty
curity
and
I
then
want
to
have
you
know:
calico
sidekick,
taking
action
to
send
a
slack
message,
or
you
know,
even
the
the
rule.
Part
of
that
may
be
a
little
bit
mixed
between
the
technologies
that
we're
using
under
the
hood,
especially
on
container
host
protection.
We
have
a
pretty
large
stack
of
technologies
there,
so
it's
going
to
be
pretty
easy
for
things
to
cross
over.
A
You
know,
so,
whatever
we
do
on
the
back
end,
we
want
to
take
that
into
consideration,
of
course,
where
Arthur
starting
right
now,
it's
simple
because
it's
just
silly,
you
know
it
and,
and
that's
it
you
know,
which
is
a
great
place
to
start,
but
in
the
end
we
want
to
have
something
that
allows
for
spanning
across
technologies
and
a
little
bit
simpler
fashion.
That.