►
From YouTube: Cloud Foundry Community Advisory Board Call [March 2019]
Description
1. YTT: The YAML Templating Tool that simplifies complex configuration management [1] by Dmitriy Kalinin (Pivotal) and Nima Kaviani (IBM)
2. CF Weighted Routing with Istio and Future Road Map [2] by Shubha Anjur Tupil and team from Pivotal
Agenda here: https://docs.google.com/document/d/1SCOlAquyUmNM-AQnekCOXiwhLs6gveTxAcduvDcW_xI/edit#heading=h.mewn94q54hla
A
B
I,
don't
have
a
whole
lot
of
updates.
I
mean
I,
put
in
everything
in
the
document.
I
think
there
are,
the
stations
are
808
or
something
so
they're
going
really
well
any
questions
or
anything
I
put
in
all
the
email
addresses
of
the
folks
that
you
need
to
you
need
to
reach
out,
do
for
any
event
related
question
or
if
you
have
a
speaking
slot
and
you
have
any
questions
or
adjustments
that
need
to
be
made
for
any
EU
summit.
Related
questions
please
hold
off.
B
A
B
I
see
most
of
the
names
here
on
the
contributor
summit
registration.
So
if
you
are,
if
you
have
not
updated
your
registration,
you
can
go
back.
Your
registration
modify
to
add
user
data.
I
mean
contributor
summit
on
to
your
registration
as
a
zero
dollar
add-on.
Just
please
do
it,
and
even
if
you
don't,
and
if
you
show
up
there,
people
we
will
not
say
you're
not
allowed
so,
ideally
it
will
help
us
with
the
room,
setup
and
everything.
So
it
will.
It
would
help
if
you
sign
up
right
now,
sweet.
A
C
C
Cappy
is
finishing
up
a
bunch
of
their
work
on
a
provisions
and
they're
planning
to
get
started
with
an
initial
effort
on
attaching
sidecar
processes
to
your
applications.
So
there's
been
a
bunch
of
design
discussion
around
that.
There's
been
a
lot
of
good
discussion
on
the
mailing
list
about
this,
but
lager
gaiters.
Finally
settle
on
a
six-month
deprecation
window
for
the
firehose
end
point
and
they're
planning
on
doing
some
work
to
help
existing
projects
migrate
to
the
new
river
slug
proxy
and
log
cache
features
that
are
replacing
all
the
old
view.
C
One
logger,
Gator
stuff
will
hear
a
bunch
of
exciting
stuff
about
networking
later
Thank
You
Mitya,
but
some
updates
from
the
networking
program
they've
completed
work
on
client-side,
transparent
load,
balancing
for
internal
wraps.
That
also
includes
things
like
transparent,
retries
and
they're,
working
now
on
transparent,
mutual
TLS
between
Athens
and
SUSE
on
the
container
network.
C
So
people
interested
in
security
I
think
are
very
excited
about
that
and
then
I
know
Gardens
continuing
to
their
track
of
work
on
better
reporting
for
CPU
usage
and
CPU
entitlement
expectations
and
they're
continuing
to
improve
their
integration
with
container
D
as
the
level
above
run.
C
and
the
garden
container
engine.
C
So
we
release
268
seven
dot.
Oh
we've
been
trying
to
release
more
frequently
there's
a
variety
of
smaller
things
in
there.
Most,
interestingly,
are
some
speed.
Ups
to
templating
and
variables,
so
hopefully
deploys
are
a
little
faster,
we're
also
starting
to
experiment
with
adding
in
a
new
life
cycle
hook,
which
is
called
pre
stop,
which
should
hopefully
provide
some
more
information.
So
clustered
services
can
better
determine
what
sort
of
procedure
is
going
to
happen
to
that
instance.
A
A
The
other
key
thing
to
mention
is
that
Stratus,
as
version
2.3,
you
two
CVEs
and
that's
important
that
are
fixed
in
there.
So
if
you're
using
Stratus,
you
should
definitely
update
to
get
that
and
then
also
they
are
adding
user
provided
service
support.
The
other
quick
highlight
is
the
brachot
project
they're
having
more
habitat
for
support,
so
we
stop
there
see
if
there's
any
question
for
extensions,
otherwise
we'll
probably
go
to
to
the
talks.
B
D
A
A
E
I
guess
yeah,
so
new
man
I
have
recently
open
storage.
This
project
called
the
ytt.
It
stands
for
llamó,
templating
tool
and
I
know
how
you
all
love
ya
know.
So
we
thought
we'll
present
this
to
to
this
group
and
see
if
it
might
be
useful
to
you
all.
You
know
maybe
there's
some
suggestions
and
feedback
and
whatnot
so
the
kind
of
a
zoom
out
for
a
second.
You
know:
why
do
you
make
this
tool
and
what
this
too
is
trying
to
solve
right?
E
So,
as
y'all
aware,
you
know,
maybe
it
was
a
few
years
ago.
One
year
ago
we
added
ops
files
to
Bosch
and
Hobbs
files
mechanism
was
meant
to
allow
people
to
customize.
I
am
kind
of
a
rebase
stuff.
On
top
of
you
know,
some
existing
manifests
that
people
ship
with
for
Bosch
right
now
the
ops
files
are
generic
right,
so
it
doesn't
necessarily
just
have
to
be.
Bashed
could
be
anything
right,
but
primarily
these
people
have
used
it
to
customize
their
boss
right,
that's
right
now.
The
challenge
with
that
is
that
you
know
some
people.
E
E
What
I
call
those
I
guess.
People
are
providers,
the
people
who
provide
the
served,
my
defense
and
then
there's
the
other
set
of
people
who
are
the
consumers
of
this
manifest
and
who
like
to
customize
things
right
and
currently,
as
you're
probably
aware,
we
use
ops
files
for
both
of
these
categories
right,
CM
deployment.
Producers
are
the
ones
that
are
using
ops
files
to
provide
some
basic
functionality
and
then
there's
also
whoever
consumes
CM
deployment
also
adds
in
their
own
ops
files,
like
let's
say,
PWS
folks
to
customize
all
that
stuff.
Now
it
works.
E
Ok,
you
know
if
the
size
is
not
that
large
of
all
this
manifests
not
in
terms
of
length
of
the
file,
but
rather
just
a
number
of
configurations,
but
it
definitely
starts
to
fail
slowly
as
you
get
to
larger
and
larger
configuration
sizes
right.
So
you
know
she
has
deployment
again
as
an
example,
it's
kind
of
challenging
to
support
some
of
those
things.
They're
provided
there's,
potentially
some
confusion
to
what
users
are
meant
to
select
for
the
ROPS
files
and
whatnot,
so
the
they
experience
you
know
could
be
better.
E
So
this,
hopefully
kinda
sets
up
some
the
background
here.
So
the
way
that
some
of
the
other
communities
out
there
have
solved
this
kind
of
a
problem
is
by
having
to
two
separate
tools
to
to
deal
with
this
kind
of
a
problem
right.
So
if
you
look
at
kubernetes
community,
for
example,
they
have
helm
and
helm
uses,
go
templating
to
you
know
to
allow
the
providers
to
customize.
E
You
know
to
offer
a
set
of
options
right
and
then,
if
you
look
at
you
know
people
who
consume
them,
they
ultimately
can
potentially
use
and
know
customize,
let's
say
with
a
k2.
You
know
augment
the
configuration
that
it
provides
right.
So
you
know
that
that
kind
of
works
out
great.
But
then
you
run
into
this.
You
know
famous
problem
of
hey.
You
shouldn't
be
templating
over
text,
because
really
what
you
want
to
be
templating
is
over
llamó
structures
right
and
the
challenges
with
templating.
E
Our
text
is
that
you
really
get
into
some
nasty
kind
of
situations
of
you
know
trying
to
figure
out
how
to
invent
stuff
how
to
escape
stuff.
How
did
all
this
kind
of
a
basic
ml
things,
but
there's
really
a
lot
of
friction
to
do
it
because
you're
not
really
working
with
llamó
you're
working
with
text
for
it?
So
you
know,
if
you
look
at
some
of
these
templating
engines
like
ginger,
you
know,
go
template.
There
is
other
ones.
You
always
run
into
this
kind
of
problem.
E
E
So
that's
the
that's
the
kind
of
a
background
for
this
tool
we
wanted.
We
wanted
to
embrace
some
of
the
templating.
You
know
solutions
that
other
you
know.
Communities
have
embraced
as
well,
but
we
wanted
our
templating
to
be
more
usable.
You
know,
have
less
ways
to
screw
up
accidentally
and
hopefully
get
rid
of
the
unnecessary.
You
know
crazy
escaping
things
and
what
are
the
things
you
have
to
do
right?
So
that's
where
ytt
tools
comes
in
now
in
the
front
of
ops
files.
E
You
know
ops
files
provide
a
syntax
right
that
allows
you
to
specify
different
paths
within
a
document.
Right
and
typically,
you
know
you
probably
all
seen
it
right.
There's
a
you
know,
a
type
of
ops
operation,
a
path
for
the
operation
and
maybe
optional,
values
right.
The
challenge
with
that
approach
is
that
a
lot
of
people
have
to
have
in
their
head
kind
of
a
figure
out.
What
is
the
path
to
the
to
the
structure
rate?
How
does
it
actually
look
and
translate
it
into
something
right?
E
Translate
it
into
the
you
know,
adjacent
path,
I,
guess
format.
Now
that
all
works
out
great,
but
I,
think
you
can
argue
that
there
might
be
more
natural
way
of
kind
of
doing
so.
Ygt
also
tries
to
solve
this
problem
as
well
by
providing
alternative
to
ops
files,
which
we
call
overlays
that
allow
you
to
do
this
ops
file
like
configurations,
but
they
don't
require
you
to
kind
of
translate
it
to
a
different
format
from
the
former
of
the
document
so
yeah.
So
that's
kind
of
the
background.
E
E
C
Think
I
think
I
just
want
to
add
is
that
one
thing
that
is
important
about
ytt
is
that
the
instructions
or
the
metadata
is
added
as
comments
in
a
document,
and
that
makes
the
entire
yeah
my
own
structure
to
remain
valid.
Through
that
you
know
the
whole
templating
process,
and
that's
probably
where
you
know
what
it
is
different
from
spit
and
write.
E
This
is
a
home
page,
I
guess
for
ITT
and
it
lists
a
few
features
and
whatnot
off
of
this
tool.
But
that's
the
boring
stuff.
The
more
interesting
stuff
is
this
interactive
playground.
That
shows
you
know
what
it
would
look
like.
You
know
to
have
some
input
in
your
you
know,
llamo
and
then
what
the
ydt
tool
produces.
So
to
give
you
a
little
bit
of
a
walkthrough
and
to
kind
of
a
show
what
we're
talking
about
what
what
you
Steven
mentioned
about
comments
and
whatnot
right.
E
E
Part
of
this
tool,
there
is
a
language.
The
language
is
called
star.
Lark,
it's
a
language.
That's
used
by
Buzzle
tool
from
Google
Google
also
maintains
the
language
itself.
It's
a
language,
that's
designed
to
be
very
useful
to
people
who
deal
with
a
lot
of
configuration
and
useful
in
the
sense
that
it
doesn't
have
a
lot
of
features,
but
it
has
some
of
the
features
that
make
it
a
pleasant
language
to
use
when
you're
dealing
with
stuff
in
templating
world,
instead
of
something
like
a
go.
E
Template
dialect
that
it's
not
quite
a
language
I
mean
it's
a
type
of
language,
but
it's
not
necessarily
friendly
to
use
language
so
to
kind
of
jump
right
in
over
here.
This
language
is
pythonic
as
it's
not
a
direct
subset,
but
it's
it's
very,
very
similar
to
Python.
So
if
you're,
familiar
with
Python
should
be,
should
be
familiar
with
this
as
well.
But
so,
as
you
can
see
over
here,
we
have
a
key
value
over
here
right
in
llamó
and
qiyam
is
Nils,
but
the
value
of
it
isn't
specified
in
llamó
directly.
E
It's
specified
through
a
comment
right
and,
as
you
can
see
over
here,
you
know
when
ytt
renders
this
content
right.
It
actually
knows
that
none
is
know
right,
so
it's
actually
translating
whatever
the
language.
You
know.
Data
structure
or
data
value
is
into
whatever
the
proper
llamo
right.
So
to
give
another
example
of
here,
if
we
change
this
to
1
2
3
right,
then
it
is
actually
1
2
3
right
now.
E
If
we
kind
of
get
deeper
into
this
right,
there's
you
know,
let's
say
string
right
and
string
is
you
know
just
double
Cori
thing,
but
because
we're
using
llamo
serialization
right
actually
in
this
example
of
you
read,
even
shows
you
right
if
we
throw
in
a
pound
over
there
right,
if
you
weren't,
just
using
proper
llamo
civilization,
right
you'll
probably
have
a
challenge
escaping
this
right,
because
pound
would
imply
that
it's
a
comment
right.
However,
ytt
again
is
working
with
the
yellow
structure.
It's
not
really
working
with
text,
so
it
is
using
this.
E
So
there
you
go
max
just
pointed
all
right,
so
does
that
make
sense
so
far,
so
of
course
you
can
get
a
you
know
fairly
complicated
things
going
on
over
here
like,
for
example,
maps,
and
you
know,
arrays
of
maps
and
all
kinds
of
other
things
right,
and
all
of
this
is
just
you
know
if
you're
familiar
with
go
at
the
end
of
it.
It
eventually
just
says
you
know
llamo
and
marshal
our
llamo
marshal
and
it
spits
out
all
that
stuff
right.
E
One
actually
one
interesting
aspect
of
this
tool
so
which
is
somewhat
unique
to
it.
Since
other
tools,
don't
really
do
it
I
think
it
actually
keeps
the
order
of
your
keys
and
the
same
in
the
same
way.
So
hopefully
it
makes
some
of
this
kind
of
a
you
know:
input-output
comparison
a
little
bit
easier
because
all
the
keys
don't
jump
around,
though
I
think
there
might
be
an
option.
E
I
think
that
so
that's
a
basic
example,
so
this
example
kind
of
demonstrates
that
we're
using
power
of
llamo
and
power
of
a
you
know
proper
programming
language,
so
we
can
get
into
something
fancier
like,
for
example,
defining
variables
right
by
the
way
you
all
can
go
to
this
website.
It's
all
you
know
it's
interactive
so
again,
yeah
play
with
it
shouldn't
be
a
problem,
but
so
here's
an
example
of
a
variable
right
variables,
no
different
from
any
other.
You
know
language
just
assign
it
and
good
to
go.
E
They
are
mutable,
I
guess
so
it's
not!
You
know
you
can
reassign
it
to
a
new
value.
It's
kind
of
a
judgment
call
in
terms
of
whether
we
should
go
out
or
not.
So
this
is
not
really
a
functional
tool.
English
right,
but
you
know
we'll
see
what
happens
with
it
all
right,
so
variables
are
pretty
boring,
let's
go
into
an
if
conditional,
so
an
if
conditional
get
things
going
in
a
more
interesting
way.
E
So,
as
you
can
see
over
here,
we
have
a
if
that
says
you
know
if
true
I
guess
it's
always
gonna
execute
to
true
right
and
it
wraps
this
key
value
pair
right
and
you
know
if
I
go
in
and
throw
in
some
more
key
values
pairs
over
here
like,
for
example,
you
know,
I,
don't
know
Z
over
here
right
now.
Both
of
these
guys
sure-
and
so
this
is.
This-
is
something
that
kind
of
a
gets
into
the
closer
to
what
you
know.
E
Some
of
this
other
templating
languages
they
provide
right
is
ability
for
you
to
have
a
way
to
customize
this
output
based
on
some
conditionals
right.
That's,
ultimately,
whether
the
power
of
this
templating
comes
in
over
ops
files
right
is
that
ops,
false,
and
really
that
you
know
they
don't
really
allow
you
to
express
some
more
complex
ideas,
I
guess
as
as
a
little
bit
of
code,
so
ytt,
given
that
it
works
with
the
mo
structure,
actually
gives
you
a
little
bit
of
sugar
around
how
to
deal
with
yellow.
E
This
continues
to
work
right,
because
the
entire
node
key
one
be
map
item
is,
is
the
entire
site
right
and
you
know,
of
course,
if
you
turn
into
false,
then
it
will
disappear.
So
that's
kind
of
that.
You
know
you
can
nest
them.
You
can
use
some
variables
and
whatnot.
You
know
nothing
that
you
know.
Nothing
should
be
too
surprising
here,
same
thing,
kind
of
happens
for
for
loops,
so
for
loops.
You
know
you
again
for
end.
You
wrap
them
pythonic
way
of
doing
all
these
things.
E
You
know
you
can
get
fancy
with
continues
and
breaks.
If
you
really
want
to
I
mean
we're
not
necessarily
trying
to
encourage
people
to
get
fancy
with
anything
right,
but
occasionally
you
do
need
a
power
of
a
for
loop
in
your
template.
So
that's
you
know,
that's
there
for
you
to
use
all
right.
So
then
this
is
where
kind
of
we
get
into
more
interesting
things
functions
right.
So
one
of
the
challenges
who
is
kind
of
dealing
with
a
lot
of
structure
right,
whether
it
be
Gamal
or
whatever
it
is.
E
You
may
want
to
decide
to
break
your
up
a
little
bit.
Make
it
more
manageable.
Somehow
right
and
one
way
to
do
so
with
ytt,
is
to
wrap
certain
structures
in
functions
and
maybe
even
move
those
funky
in
two
different
files.
Right,
like
you,
know,
module
right.
So
an
example
of
here
right
is
that
we
have
a.
We
have
a
function
called
samyama
that
you
know.
Has
a
few
map
item
keys.
You
know
the
keys
could
be
as
complex
as
you
want
and
I
would,
just
you
know,
say
the
value
of
the
ml
keys.
E
All
your
parameters
are
getting
passed
to
and
whatnot
in
you
know,
since
this
is
pythonic,
you
can
use
keyword
arguments
to
maybe
more
be
more
descriptive,
but
yeah,
nothing
too
surprising,
but
suddenly
you
can
break
up
some
of
the
larger
yeah
else,
maybe,
for
example,
in
abortions.
You
have
a
lot
of
different.
You
know
jobs
inside
instance
group.
E
So
what
you
may,
whether
he
use
right,
because
you
can
call
function
multiple
times
about
that,
and
so
it
gets
a
little
bit
interesting
and,
as
I
was
saying
just
earlier,
you
can
pull
that
out
into
a
separate
file.
So,
for
example,
in
this
example
removed
some
of
those
functions
into
functions
that
leave
that
llamo
and
then
just
calling
it
you
do
have
to
import
them
explicitly.
We
are
fairly
specific
about
that.
I
guess
here's
a
very
gun
player
and
you
know,
and
you're
able
to
kind
of
reuse
them
right.
E
What's
what's
also
cool
kind
of
about
this
right
is
the
these
files
right
are
entirely
kind
of
a
self-contained
right.
I
mean
I,
guess
if
they
keep
on
referencing
other
files,
then
it's
really
a
collection
of
files
that
self
attained
right,
but
this
kind
of
starts
tying
into
an
idea
of
you
know:
shipping
libraries
that
may
be
of
use
to
people
right
so,
for
example,
I've
been
playing
with
a
lot
of
kubernetes
recently,
so
I've
been
kind
of
a
toying
around
with
this
kubernetes
library.
I
am
a
kubernetes
library.
E
Really
just
provides
you
with
a
set
of
files
that
provide
some
functions
that
will
produce
you
several
objects
right
and
so,
for
example,
you
wanna,
say
I
want
a
basic
application
and
those
set
of
objects
suddenly
get
turned
into
I.
Don't
know
a
deployment
service,
you
know
horizontal
put
out
to
scale
and
what
right,
so?
E
You
can't
build
up
abstractions
with
this
kind
of
a
you
know
with
this
kind
of
facilities,
and
you
know
it
really
depends
on
what
kind
of
obstructions
you
looking
for
it.
So
you
can
make
it
very
useful
or
you
can
make
this
very
annoying
right
to
use
pause
for
a
second
over
here.
Any
any
questions
so
far
in
the
comments.
E
You
know
now
that
we
know
about
all
these
conditionals
and
whatnot
you
you
do
want
to
provide
some
kind
of
input
from
the
user
eventually
right
to
these
templates
right
to
actually
do
something
useful
right.
So,
for
example,
and
CF
deployment.
You
know
we
have
lots
of
ops
files
that
try
to
signify
particular
features
right,
like
we
enabled
in
those
functionality
or
I,
don't
know
disabled
at
sea,
or
something
like
that
right.
So
a
lot
of
that
stuff,
I,
really
boolean's
and
some
of
those
boolean
actually
interact
with
each
other
item
in
different
ways
right.
E
You
know
into
this
language
and
what
I
mean
by
that
is,
for
example,
currently
ytt
and
probably
in
future
as
well,
doesn't
have
a
concept
of
time,
for
example,
right,
there's
no
way
to
say
like
time
that
now
right,
there's
also
no
network
access
or
file
system
access
right.
The
only
a
to
files,
for
example,
is
true.
This
load
facilities
that
we
expose
right,
so
the
the
entire
interpreter
is
kind
of
locked
down
to
my
fairly
paranoid
believes.
E
So
it's
it's
kind
of
a
it's
an
interesting
advantage
of
of
this
kind
of
a
tool
versus
you
know
you
want,
could
imagine
right
like
why
use
this
tool
versus
using
like
a
language
right,
Ruby
or
something
like
that
right
to
write
all
your
configuration
file
right.
Well,
one
aspect
to
it
right
is:
you
know
when
you're
running
some
Ruby
code
right,
you
don't
necessarily
know
what
exactly
it's
doing
right.
So
it
becomes
very
hard
to
share
some
of
those
things
right.
E
A
E
No,
but
it's
it's
a
single
binary
written
in
go
so
anyone
can
you
know,
download
it
and
use
it
to
their
eyes,
desires
or
by
a
very,
very
good
point
right.
This
is
not
just
an
online
thing.
It's
a
it's,
a
binary
that
you
just
download
off
of
github
releases
and,
and
you
use
it
any
way
you
want
to
use
it
yeah.
E
So
you
know
now
that
we
know
some
of
these
basics
of
what's,
provided
you
know
there
isn't
really
much
beyond
that.
In
terms
of
you
know
what
people
doing
with
templates
are.
Actually,
you
know
at
last
two
weeks
ago
or
so
hours,
for
example,
working
with
Chris
Deuter
to
kind
of
play
around
ways
like
what
would
CF
deployment
look
like
if
one
would
use
something
like
this
right
and
I
will
obviously
CF
deployments
tree
large
rate.
So
that's
not
something
that's
gonna
just
happen,
even
if
it
ever
does
happen.
E
But
what
what's
interesting
you
kind
of
a
you
know
once
you
start
dealing
with
a
lot
of
configuration,
you
kind
of
start
thinking
about
some
of
the
abstractions
right
and
maybe
to
give
you
a
little
bit
of
taste
of
what
those
abstractions
would
look
like.
If
you
go
to
you
know,
they'll
give
up
organizations
that
holds
ytt.
There
is
a
thing
called
Kate's
limb
and
unfortunately
I'm
a
bush
example
of
how
that
would
look
like.
But
you
know
one
could
imagine
right
that
you
pull
up
a
library.
E
That's
from
this
repo
right
and
all
you
say
to
deploy
a
kubernetes
application.
Right
is
something
like
this.
Where
you
have
you
know,
please
make
me
an
app
that
has
some
name
and
there's
some
basic
configuration
of
this
particular
image
and
arguments,
and
then
I.
You
know
configure
port
and
that's
pretty
much
it
and
now
there's
some
other
boilerplate
going
on
over
here
with
this
for
template,
replace,
but
that's
not
too
interesting,
but
the
gist
of
this
is
that
this
ultimately
produces
a
chunk
of
llamo
rate.
E
That
kubernetes
is
actually
very
happy
to
deploy
and
configure
all
kind
of
together
right,
so
that
kind
of
a
bring
some
of
these
things
together
right
and
as
you
can
see
over
here,
you
know
we
don't
actually
allow
you
to
configure
much
else
beyond
this
three
or
so
things.
Now
that
raise
the
question.
Well,
if
you
can
only
set
the
name,
you
can
set
the
image
and
arguments
and
you
can
set
the
port.
What
about
all
the
other
garbage
that
I
typically
want
to
set?
E
E
The
most
easy
approach
right
is
that
I
keep
on
adding
stuff
to
this
library
until
everyone
is
happy
right,
but
that's
gonna
turn
very,
very
bad
quickly,
right,
because
then
it
would
be
pretty
much
exactly
all
of
the
configuration
that
kubernetes
provides.
Let's
say
right:
we
would
have
to
be
here
right,
so
this
goes
back
to
the
notion
of
ops
files.
Right
is
you
wanna,
allow
your
users
to
customize
whatever
is
given
to
them
right,
but
you
wanna,
you
want
them
to
customize
without
you
having
to
worry
about
how
they
customize
it
right.
E
E
E
You
know
annotation
right
now
in
ops
file,
world
right,
of
course,
you'll
have
to
figure
out
okay,
well,
the
path
for
this
is
going
to
be
metadata
annotations,
and
then
this
thing
over
here
right
and
as
people
familiar
with
ops
files,
also
note
that
you
know
because
there's
a
slash
in
the
value
you
have
to
escape
it
in
a
particular
way
in
in
this
path.
So
it
doesn't
get
it's
not
that
pretty
or
as
pretty
as
one
could
hope.
E
However,
in
this
new
way
of
doing
it
overlays,
what
you
do
is
you
define
a
different
file
or
different
llamo
I
mean
or
I?
Guess
you
can
just
technically
stick
it
in
it
there
as
well,
that
has
a
few
annotations
attached
to
the
objects,
so
I
think
that's
the
first
time,
I'm,
actually
showing
you
guys
an
annotation
attached
to
the
document
or
chief
rate.
E
So
what
this
says
right
is
that
says,
find
me
a
document
that
contains
metadata
named
example,
ingress
one
content
right,
so
there's
different
ways
how
to
much
things
and
one
of
the
built-in
kind
of
a
selectors
is,
is
the
way
to
just
say
you
know.
Does
some
other
object
contain
this?
Meaning
object
will
subset
right,
and
so
you
know
in
our
example
of
here
it
will
find
this
object.
E
You
won't
find
this
object
right
because
the
name
is
different
and
ultimately
then
you
just
all
you
have
to
do-
is
you
just
dump
the
same
structure
at
metadata
annotations?
You
know,
let's
say
this
thing
right
and
then
you
again
annotate
what
you
actually
want
to
do.
Is
this
particular
thing
right?
So
in
this
particular
case,
we're
saying,
when
I
remove
this
annotation
right
and
by
default
map
items,
get
mapped
or
get
matched
by
their
name
right.
So
of
course,
you'll
find
this
guide
and
I
will
remove
it.
E
So
that's
actually
going
to
be
the
outcome
of
this
row
now,
maybe
a
more
fully
featured
example
here
is,
you
know,
let's
find
the
ingress
to
and
insert
some
things
right.
So
here
we're
saying
it's:
okay
to
insert
these
two
new
things
and
some
of
the
I
guess
facilities
over
here
is
trying
to
be
somewhat
protective.
So,
for
example,
if
I
remove,
if
I
remove
this
annotation
over
here,
I
will
actually
something
across.
So
if,
if
I
remove
this
over
here
nope,
that's
not
the
one.
E
What
you
don't
want
to
show
right
so
I
guess
it
won't
be.
It
won't
be
actually
easily
shown
here
in
this
example.
But
the
idea
here
is
that
we
actually
have
to
explicitly
say
that
this
item
is
missing
and
it's
missing
in
the
original
document
right
to
avoid
accidentally
overwriting
kind
of
certain
things
right.
So
the
idea
behind
this
is
just
like
how
ops
files
are
by
default.
They
expect
the
keys
to
be
in
the
documents
right-
and
sometimes
you
have
to
put
in
some
question
marks.
E
Overlays
are
quite
similar
in
that,
but
they
go
a
little
bit
even
further
and
are
fairly
explicit
about
some
of
the
content
that
you're
inserting
now
some
of
those
features
you
can
turn
off
and
turn
on
so
to
customize.
It
kind
of
alright,
but
the
gist
of
it
is
that
it
tries
to
help
you
avoid
accidentally,
making
typos
and
all
kinds
of
other
things,
or
maybe
you
know
accidentally
inserting
things
in
wrong
places,
so
that's
kind
of
the
gist
of
overlays
right.
E
The
gist
of
it
is
that
in
Waikiki
kind
of
tries
to
cover
both
of
these
audiences
and
we
think
that
providing
templating
facilities
is
is
better
for
providers
and
then
providing
overlaid
facility
is
better
for
people
who
actually
customized
the
configuration.
So
max
is
saying
that
I
have
a
little
bit
of
time
left.
Does
anyone
have
any
questions,
any
any
discussion
topics
or
anything
like
that?.
A
So
I
don't
see
anything
on
the
chat.
We
probably
need
to
go
to
the
to
the
next
talk.
I
think,
let
me
say
to
everybody:
I
mean
I,
think
personally,
that
this
has
a
chance
to
revolutionize.
The
way
you
do.
Yamo
Demetri
is
not
gonna
say
that,
but
I
know
he's
thinking
that
aneema.
This
is.
This
is
awesome.
I,
think
you
know
you
you
all
should
try
it
because,
basically,
you
know
now
you
can
actually
write
real
programming
language
and
you
can
annotate
and
it
just
changes
things
there's
so
many
directions
on
this.
A
A
D
Yeah
so
I'm
gonna
demo
weighted
routing,
which
is
one
of
the
first
features
of
sto
integrated
with
Cloud
Foundry.
The
is
do
networking
tier
is
deployed
side-by-side
with
what
already
exists.
So
when
you
include
sto
in
your
deployment,
it
adds
an
sto
domain
tier
CF
domains
and
if
you
push
apps
to
the
isseo
domains,
then
you
can
leverage
sto
features
like
weighted
routing,
so
the
use
case
for
weighted
routing
specifically
is
like
a
be
testing
or
canary
releases
or
gradual
rollouts.
D
D
You
can
see
that
every
wait
every
route
has
a
wait
now
associated
with
it,
so
the
wait
for
by
default
is
gonna,
be
one
so
the
way
for
the
one
route
that
we
have
is
one
right
now,
so
we
want
to
roll
out
version.
Two
of
this
app
it'll
also
get
a
weight
of
one,
which
is
the
default,
which
would
mean
50%
of
the
traffic
would
go
to
version
1
and
50
percent
would
go
to
version
2.
Let's
say
we
don't
want
that.
D
D
Cool
so
check
that
it
got
that
value
cool,
so
the
weight
has
been
updated
to
nine
all
right.
So
now,
let's
set
up
a
route
for
version
2
and,
as
we
just
talked
about,
the
default
weight
will
be
1,
so
the
weight
for
version
1
is
9.
The
weight
for
version
2
is
1,
so
that
means
90%
of
traffic
should
go
to
version.
1
and
10
percent
of
traffic
should
go
to
version
2.
D
We
can
see
that
again
in
route
mappings,
one
of
the
routes
has
weight
1
and
the
other
one
has
weight.
9
it'll
actually
take
a
sec
for
this
to
start
working
because
it
it's
hitting
a
copy
end
point
and
then
for
the
SEO
components
like
copilot
and
pilot
to
sync
it
up
with
the
router
that
polling
interval
is
every
30
seconds.
So.
D
D
D
D
B
Yeah,
so
we're
only
supporting
numerically
so
the
way
it
has
to
be
between
one
and
one
twenty
eight
and
we
are
supporting
the
way
it
calculates
is
there's
a
numerator
and
the
denominator,
so
your
weights
could
add
up
to
more
than
100
but
yeah
we
like,
if
you
have
more
than
hundred
apps,
that
are
mapped
to
the
same
route,
be
probably
like
I,
don't
think
that's
going
to
work
because
we
do
in
support
fraction.
It's
in
fact
it's
to
doesn't
support
fractional
waves
right.
A
A
B
Add
up
to
because
it's
a
numerator
and
denominator
right,
so
it's
like
it
can
be
anywhere
between
1
and
128,
and
it's
basically
like
whatever,
let's
say
app:
1
has
a
weight
of
1.
Absolutely
as
a
weight
of
you
know,
1
we
do
a
1
upon
1
plus
1
right,
so
it's
a
1
upon
2
and
1
upon
2,
so
it
doesn't
have
to
add
up
to
100,
actually
I.
Think.
A
B
It's
actually
been
around
in
the
legend
of
CF
deployment
and
you
have
st
orally
is
we
have
instructions
and
how
you
can
install
these
tod
leaves
only
the
CSC
li
plugin
is
you
know
where?
Otherwise,
it's
been
there
for
a
while
in
these
charities,
and
we
had
instructions
on
how
you
can
set
it
up
once
you
have
also,
I
should
mention
that
we
do
hope
to
actually
support
percentage
weights,
but
given
like
that,
there
are
some
cap
e
limitations.
We
just
choose
to
do
numeric
weights
first.
E
B
So
I
think
the
feedback
we've
heard
in
general
is
that
blue
team
deploys
are
two
basic
and
most
customers
find
it
like
doesn't
meet
their
needs
because
it's
really
like
okay,
you
create
another
app,
you
map
it,
and
then
you
switch
over
at
some
point.
But
this
is
not
production
ready,
yet
it's
still
experimental.
B
B
B
We
went
with
that
approach
so
that
we
can
at
least
start
by
pushing
out
features
and
have
customers,
use
it
and
start
getting
feedback
and
we
are
taking
the
approach
of
releasing
some
of
these
features,
which
are
not
currently
supported
in
the
current
routing
control
plane
like
weighted
routing,
and
we
are
also
now
working
on
app
to
app,
MPLS
and
and
and
new
features.
The
container
networking
which
don't
exist
in
the
current
container
networking
layers,
and
our
hope
is
that
we
will
be
able
to
this
is
sort
of
like
here.
B
E
B
Yet
yeah
we
haven't
tested
it;
actually
it
might
just
work,
I
haven't
tested,
it
I
think
it
might
just
work.
We
are
focused
on
my
client
side,
load,
balancing
retries
and
timeouts
and
M
TLS
for
app
to
app
communication.
First
and
I
think
we
do
routing
should
work,
we
haven't
tried,
it
I
could
try
it
and
tell
you
I've.
C
A
B
I
know
sitting
right
next
to
me,
but
scale
is
one
of
the
issues
right,
so
we've
tested
external
rods
to
20,000
routes
and
20,000
apps,
but
we
haven't
tested
it
to
like
250
thousand.
Yet
the
other
issue,
I
can
see
is
just
parity
right
like
we
cannot
like.
We
cannot
make
this
production
ready
until
it's
maybe
at
parity
with
the
go
router,
but
that's
something.
Maybe
we
should
that's
an
assumption.
We
should
check,
but
I
think
scale
is
definitely
one
of
those
issues.
A
B
So
I
think
one
of
the
big
one
of
the
next
things
we
should
come
pretty
soon
as
support
for
dynamically.
You
configured
sidecars,
supporting
like
client,
side
load,
balancing
tree
trials
and
timeouts
for
app
to
app
communication
and
transparent
MPLS
for
app
to
app
communication
and
then
we'd
be
focused
on
M
TLS,
for
from
the
edge
envoy
to
the
sidecar
envoys
and
I
think
we
will
work
on
scale
and
parallel
and
then
I
think.
B
Once
we
have
those
things
we
are
still
trying
to
figure
out
our
roadmap,
but
I
think
we
will
start
working
on
a
lot
of
the
core
outer
parity
features
right.
We
need
to
get
to
parity
at
some
point
to
be
able
to
deprecate
the
core
router
and
actually
start
using
this,
and
that's
still
a
very
long
timeline,
because
we
will
have
to
give
the
community
a
long
enough
transition
window,
but
we
have
start
working
on
parity
from
the
go
router
to
this.
B
So
things
like
isolation,
segments
route
services,
sticky
sessions
supporting
you,
know,
multiple
domains,
custom
context,
paths.
We
don't
do
any
of
that
right
now
in
this
right.
So
there's
a
long
list
of
go.
Router
parity
features
that
we
need
to
get
to
and
I
I've
you
scale
as
also
being
one
of
them,
because
the
go
router
today
like
has
been
proven
at
scale
and
is
being
used
at
scale.
A
B
So
I
think
when
I
started
on
the
routing
team
about
a
year
and
a
half
ago,
one
of
the
questions
we
asked
was
like
what
does
it
mean
to
parity
with
like
what
all?
What
are
all
the
things
that
good
outer
supports
right,
because
the
go
router
actually
has
been
in
existence
for
six
and
a
half
years
or
something
and
it
came
to
us
from
B
and
there.
So
we
actually
went
in
and
dug
in
long
list
of
things
that
the
go
router
supports,
which
I,
don't
think
is
an
exhaustive
list
of
everything.
B
B
Absolutely
I
think
that
is
our
intent
with
trying
to
release
this
an
an
intramental
way
right.
We
don't
want
to
beat
all
the
way
to
like
you
know.
We
have
parity
till
we
even
like
have
like
a
few
features
out
and
we
will
keep
releasing
features
incrementally
on
this
routing
the
troll
plane,
and
we
are
hoping
that
eventually,
it
will
reach
a
place
where
some
customers
actually
use
it
enough.