►
From YouTube: OpenShift Commons Briefing #130 Function-level Routing with Gloo and Envoy - Idit Levine (Solo.io)
Description
Function-level Routing with Gloo and Envoy with Idit Levine (Solo.io)
Gloo is a function gateway built on top of the Envoy Proxy. Gloo provides a unified entry point for access to all services and serverless functions, translating from any interface spoken by a client to any interface spoken by a backend. Gloo aggregates REST APIs and events calls from clients, “glueing” together services in-cluster, out of cluster, across clusters, along with any provider of serverless functions. In this briefing, Idit Levine will give an introduction to Gloo and demonstrate how to use Gloo with OpenShift.
Guest Speaker: Idit Levine, solo.io Founder & CEO
Idit Levine is the founder and CEO of solo.io, where she is aiming to streamline the cloud stack. Prior to founding solo.io, Idit was the CTO of the cloud management division at EMC and a member of its global CTO Office. At EMC, Idit led, designed and implemented project UniK, an open source platform for automating unikernels compilation and deployment and project layer-x, an open source framework for cross-cluster scheduling . At solo, Idit recently released Squash, an open source platform for debugging microservices applications and Gloo, a function gateway built on top of the Envoy Proxy.
A
Hello,
everybody
and
welcome
to
another
openshift
Commons
briefing.
This
time
we
have
another
server
list
topic
to
talk
about
today.
There's
some
wonderful
work
going
on
at
solo
around
some
new
projects
that
Adeeb
Lavigne,
who
is
the
founder
and
CEO
of
solo,
is
going
to
talk
about
today.
I'll,
let
her
introduce
herself
and
her
projects
and
their
offering,
and
we
can
have
some
chat
in
the
chat
as
usual
and
they'll
be
live
Q&A
at
the
end.
B
Take
it
away
thanks
a
lot
thanks
man,
so
thank
so
much
for
having
us,
so
my
name
is
indeed
like
we
said:
I'm,
the
CEO
and
founder
of
core
of
so
Leo.
This
is
a
small
company
based
on
Boston
and
basically,
what
we're
doing
is
we're
doing
a
lot
of
stuff
that
related
to
innovation
and
open
source
and
Wako
system
service
and
so
on,
but
we
also
have
our
own.
You
know
a
product
that
tolling
a
real
enterprise
from
them.
B
So
if
you
should
just
start
going
and
explain
you
why
what
we
doing
and
why
we
doing
so,
ok,
so
this
is
the
way
I
see
the
echo
system.
Today
there
is
monolithic
application
there
are
actually
exist,
is
most
of
the
enterprise
right
there.
This
is
where
usually,
the
core
business.
This
is
an
application
that
people
was
building
for
the
last
12
years
or
so
they're
going
to
human
to
manage
them
by
something
something
like
NCBI,
for
instance,
for
money
and
then
they're
going
to
need
to
to
a
tools
to
actually
monitor.
B
So
they
were
going
to
use
some
APM
for
that
in
order
to
get
the
metrics
and
they're
going
to
use
something
like
slung
to
get
the
logging
and
most
likely.
These
architecture
is
in
SOA
a
service-oriented
architecture,
but
there
is
also
the
new
or
which
is
the
micro
services
which
most
of
the
enterprise
probably
most
likely
want
to
move,
because
it's
faster
and
then
these
micro
services
are
going
to
to
manage
by
something
like
open
shift.
Right
and
they're
going
to.
B
You
know
manage
that
the
stage
the
deployment
and
so
on,
and
it
will
still
need
you
to
use
some
tools
in
order
to
make
sure
that
you
know
it's
always
running
and
the
methods
is
working.
So
we
do
use
something
like
parameters
for
metrics,
for
instance,
just
because
the
scale
has
to
be
much
much
much
louder.
B
They
use
something
like
open
Tracy,
because
now
it's
all
about
distributed
application
and
when
it's
distributed
application,
it's
really
really
hard
to
get
the
stage
of
the
microscope
and
the
logging
you're
getting
a
blob
of
log
and
it's
hard
to
understand
which
belong
people.
So
there
will
be
something
like
open
tracing,
basically
giving
a
a
transaction
ID,
and
that
way
it's
aggregating
all
the
right
logs
and
that
to
be
micro-services.
But
there
was
also
a
very
interesting
echo
system
called
several
s
most
likely
right
now.
B
I
think
that
most
of
the
people
actually
running
it
in
production
will
run
it
in
some
of
the
cloud
provider
like,
for
instance,
AWS,
Oh,
Google
and
so
on,
and
which
is
the
main
purpose
of
actually
creating.
This
movement
was
the
gluing
of
the
services.
So
now
it
will
be
running
because
you
most
likely
run
on
AWS,
so
some
some
other
cloud
you
most
likely.
B
They
will
manage
your
function,
your
lambda
and
therefore
you
will
use
their
tools
like
cloud
watch
for
matrix
and
x-ray
for
logging,
and
all
this
architecture
is
really
really
big
in
epen
treatment,
because
mainly
it's
gluing,
then
gluing
the
services,
which
means
that
every
time
did
someone
put
something
in
the
service
will
create
some
event.
Those
function
will
run
it's
also.
A
very
very
economic
is
solution,
because
you're
paying
only
for
what
you
want.
So
there
is
all
the
system,
and
then
the
enterprise
are
looking
at
that,
so
this
is
still.
B
But
the
question
is
how
to
do
that.
It's
really
really
hard.
But
let's
see
what
is
the
option
that
those
enter
process
today,
so
the
first
option
that
it
has
it
just
not
to
move
right.
I
mean
this
is
hard
and
you
know
if
something
is
working.
Monolithic
is
working.
Maybe
they
shouldn't
move,
but
the
problem
with
that
is
that
this
core
monolithic
application,
the
business
use
case.
It's
really
really
hard
to
add
new
feature
monolithic.
It's
really
really
complicated.
B
Usually
it's
spaghetti
code
and
it's
really
hard
to
to
understand
the
system,
add
features
and
then
after
it,
after
you
doing,
you
need
to
deploy
monolithic
application,
which
is
another
problem.
So
it's
really
really
hard.
So
again
it
can
stay
there,
but
then,
if
one
of
their
competitors
didn't
move,
they
probably
move
much
faster
than
there.
So
liberalism
helps
you
number
two
that
they
have
is,
and
this
is
done
by
a
lot
of
enterprise.
It's
basically,
they
saying
look,
no
worries
we're
going
to
all
these.
B
How
are
these
crazy,
good
people
and
they're
going
to
take
every
green
application
that
we
need
to
do
every
new
application
that
you're
into
right?
They
will
write
it
in
the
newest
tech
service,
but
we're
still
going
to
keep
the
monolithic
application
in
monolithic
ecosystem,
because
it's
just
you
know
again
it's
hard
right.
B
So
the
problem
with
that
is
that,
in
the
end
of
the
day,
you
know
you're
still
running
your
core
application,
your
core
business
application
that
you
actually
invest
most
of
the
time
and
and
it's
your
core
business
in
a
monolithic
and
to
add
feature
that
is
still
slow.
So,
even
if
you
do
some
green
application,
you
know
on
the
new
technology.
B
Still
you
know
it's
not
really
helping
you,
because
this
is
usually
most
likely
only
a
support
application
and,
of
course,
you
kind
of
like
creating
a
silo
team
right
now
right
because
you
have
those
guys
whose
application-
and
here
are
your
guys,
who's
doing
the
new
stuff,
and
there
is
a
huge
of
competition
between
them,
those
that
continually
feature
it's.
It's
like
it's
creating
a
lot
of
mess
and,
of
course,
different
to
link
and
so
on.
Okay,
so
option
number
three
and
again
there's
a
lot
of
fun
depressors
trying
to
do
that.
B
It's
basically,
let's
blow
up
the
micro
there's,
a
monolithic
application,
big
bang,
refactoring
we're
going
to
destroy
the
monolithic
application
in
every
feature.
Then
existence
monolithic
application.
We
will
write
it
in
either
several
as
for
my
tests.
So
this
is
a
really
really
nice
idea,
but
you
before
it's
never
working.
It's
really
really
really
hard
to
do
that.
This
is
like,
as
I
said
like
it
could
be
like
a
years
of
application
with
spaghetti
code
which
a
lot
of
logic
built
into
and
now
to
go
and
refactor
everything
is
just
hard.
B
It's
really
really
are
and
and
therefore
a
lot
of
the
people
just
quitting
in
the
middle.
The
trying
this
is
these
things
and
then
eventually
just
just
topping
in
the
middle,
but
let's
say
that
they
did
succeed
that
and
then
they
refactor
the
application.
It's
probably
taking
them
between
eight
you
on
this
you
or
do
you
didn't
get
any
new
PC.
It's
like
I'm,
renovating
this
room,
but
everything
I'm
doing
is
basically
wiping
behind
a
room
there
wall
so
again
not
the
best
solution,
so
the
so.
B
The
question
is:
what
is
the
right
solution,
because
people
doing
it
right,
I
mean
people
like
like
a
Twitter
and
people
like
cliff.
They
actually
make
right
there,
monolithic
application
to
micro
services
and
the
way
they
did.
It
is
basically
by
putting
something
on
top
of
it,
so
basically
extend
the
monolithic
application
to
feature
in
the
micro
service
and
sever
less,
but
treated
is
one
application
and
then
gradually
refactor
the
monolithic
application.
So
when
I
looked
at
this
I
said
to
myself,
this
is
great.
B
The
question
is
how
to
do
it's
the
most
seamlessly
and
when
I
notice
is
that
the
smallest
unit
of
compute
that
share
between
all
these
things
is
basically
function,
if
you
think
about
it.
Basically,
every
monolithic
application
of
micro
service
application
as
an
exposed,
API
and
I
can
treat
them
as
a
function.
So
if
I'm
doing
this
and
I'm
can
actually
Ray,
which
you
have
no
really
greatly
but
actually
bring
the
the
monolithic
application
and
micro
services
to
function.
B
I
can
actually
do
something
like
this
I'm
calling
it
I
put
up,
but
it
could
be
called
any
composing
application
and
so
on,
which
is
the
ability
to
actually
put
all
the
new
feature
and
extend
them
in
one
of
the
application
due
to
micro,
service
and
service
and
then
gradually
we'll
hope
that
makes
sense.
So
if
we
can
do
this
now,
it's
interesting
now
we're
getting
a
fast
delivery.
B
You're
always
moving
to
the
right
target,
and
you
know,
and
you
gradually
moving
it
in
the
smallest
unit
of
compute,
which
means
that
you
don't
refactor
everything
you
just
be
taking
piece
by
piece
and
moving
it
in
your
in
your
spare
time.
I
think
that
the
best
way
to
understand
the
vision
is
just
by
showing
it
so
I
will
show
you
a
quick
demo.
B
And
okay,
so
I
have
you
a
monolithic
application?
This
is
not
even
mine.
Actually,
this
is
a
reading
by
pivotal,
as
you
can
see,
it's
a
spring
string
application.
It's
the
Lord
of
the
spring
application,
basically
right,
so
it's
the
pet
stores
and
I
can
actually
show
you
the
code.
The
code
is
the
people
that
I
called
I
didn't
change
it.
It's
really
an
application
that
we,
you
know
we
just
still
can't
install
so
we
put
it
running
actually
what
we
did
is
lift
and
ship.
B
We
basically
took
it
lifting
ship
it
and
put
it
on
open,
okay,
open
shift.
Now
we
have
that
running
there,
and
this
is
a
Java
core
advice.
So
this
is
also
a
Java
code
as
if
it's
it's
a
working
and
fantastic
and
then,
when
I'm
coming
to
the
vets.
What
I
see
is
that
there
is
two
car
and
I
really
want
to
add
another
and
I
want
to
add
the
location.
Call.
The
problem
with
that
is
that
I
have
a
new
engineer
and
I
really
wanted
to
get
it.
B
So
what
this
guy
need
to
do,
because
it's
new
is
to
understand
the
application
to
go
figure
out
what's
going
on
in
this
spring
application.
That
is
really
really
kind
of
like
hard
and
not
really
trivial.
To
understand.
You
need
to
add
a
function
right,
the
actual
functionality
for
that
for
bringing
the
location
if
need
to
test
it,
the
functionality
you
need
to
regression
test
it.
You
need
to
deploy
a
monolithic
application
which
is
never
easy
to
all
of
this.
B
In
order
to
add
one
column
or
what
we
can
do
is
what
I
did
here:
I
wrote
a
micro
services
in
go
again
running
on
an
open
tracing
in
open
air
and
how
I'm
doing
is
basically
going
directly
to
the
database
and
just
stacking
all
the
information
that
I
need
for
this
page.
So
now
the
only
thing
I
need
to
do
with
glue,
which
is
this
UI,
is,
as
you
can
see,
already
discover
everything
they're
running
on
open
trade
on
open
a
shift.
B
So
you
can
see
all
the
application
that
running
blue
is
running
on
open
sheets
and
so
on
and
in
the
bed
store
that
we
just
so
even
the
micro
services
enjoy
I
already,
basically
put
it
install
it.
You
know
I
deploy
it
on
on
opposite,
and
now
there
is
the
routes.
So
the
only
thing
that
I
said
right
now
is
that
everything
that
coming
to
this
domain,
you
need
to
go
to
this
monolithic
application.
B
What
we're
going
to
do
right
now,
we're
just
going
to
add
another
route
and
what
we're
going
to
do
is
we'll
say
everything
that
going
to
beds
your
HTML
for
any
type
of
request.
What
we
want
to
do
is
to
run
these
micro
services.
Ok,
that's
it
very
simple
to
write.
Now
everything
will
go
to
this,
but
if
someone
will
go
to
read,
HTML
will
go
to
my
micro
services
and
go
so.
Let's
go
right
now
back
to
the
application
and
see
what
happening
this
is
a
java
application.
B
This
is
the
java,
but
when
I'm
clicking
here,
this
is
all
ready
to
go
now
notice,
a
quick
it
was
and
the
reason
it
quick
is
because
the
technology
of
envoi
and
everything
that
we're
doing
with
it
so
I
will
explain
in
a
second.
So
now,
let's
look
at
this.
The
contact
is
not
working
as
well,
so
I
can
go
and
ask
my
engineer
to
fix
it,
but
let's
for
fun
of
it
just
add
a
function
here.
B
So
basically
on
AWS
is
one
I
have
all
those
function
so
now
the
only
thing
that
I
really
need
to
do
to
go
back
to
the
route
and
click
new
routes.
I
will
come
here
and
I
will
do
slash
contact
HTML,
which
is
the
page
that
I
want
to
fix,
and
I
will
say
every
time
that
is
it
I
want
you
to
go
to
AWS
and
one
this
lambda
for
me
and
by
the
way,
lambda
is
always
returning
JSON,
but
I
really
want
to
show
it
in.
B
You
know
in
the
HTML,
because
I
want
to
show
it
in
the
browser
to
create
an
address
for
me,
but
exactly
to
do
that
today,
you
can
do
it
only
with
the
awsm,
a
gateway
which
will
cost
you
quite
a
lot
of
money.
So
we
did
that
so
again,
the
application
everything
is
going
to
the
Java
monolithic
application
and
didn't
touch
it.
I
didn't
need
to
redeploy
it
it's
all
there.
It's
not
even
my
call
on
top
of
it
I
extended.
Oh
I
change
it
to
go
to
this
route
when
I
wanted
to
do
it.
B
Micro,
micro
services
and
now
also
going
to
tie,
told
him
that
if
someone
clicking
on
contact
I
want
you
to
go
to
edibles
and
run
this
function,
so
now,
let's
go
inside
see,
that's
actually
worked
to
again.
This
is
the
Java.
This
is
the
Java.
This
is
the
go
micro
services
and
I
will
go
to
the
contact,
and
hopefully
it
will
work
and
its
work,
so
I
just
spin
up
a
nodejs
function
in
AWS
and
I
can
go.
Actually.
B
All
of
this
is
open
in
order
to
show
you
that
I'm
not
lying,
but
it's
not
like.
So
this
is
basically
the
iadapt
solution
and
again
we
can
experience
for
moment
more
more
functionality
and
and
and
now,
let's
drill
and
understand
what
we
actually
did
that
so
sick.
It's
both
the
presentation
back
okay.
So
when
we
design
glue
and
glue
basically
cold
like
this,
it's
because
we're
planning
to
glue
the
environment
and
the
technologies
right.
Well,
we
don't
what
we
pay.
Attention
is
to
three
thing
that
was
important
for
us
design,
one
of
them.
B
It
was
important
that
you
know
like
every
a
packet
where
we
basically
centralized
everything
right,
so
we
centralize
the
security
observer
ability
and
the
traffic's
right.
So
you
have
one
place
that
you
can
manage
it
for
the
echo
system,
which
is
great.
The
second
thing
that
was
important
for
us
Oh
s-sorry.
So,
as
you
can
remember,
we
talked
about
taking
all
these
monolithic
application
and
cut
it
to
function.
B
The
last
thing
that
we
did
is
by
actually
by
doing
this,
we
decouple
everything
we
will
decouple
there
front
and
from
the
back
end
and
I
think
this
is
a
really
really
important
thing,
because
every
proxy
that
exists
is
routing
on
the
on
the
service
level,
which
means
that
the
back
end
have
to
have
some.
You
know
the
bacon
format
or
design
have
to
be
relevant
to
the
client.
B
With
with
glue
you
totally
be
totally
decoupled,
which
means
that
there
is,
you
know
we
we
have
a
transformation
filter,
that's
transformed
it,
so
you
can
actually
take-
and
you
know,
use
a
regular
client
to
call
Geo,
PC
right
and
so
on.
So
it's
really
really
giving
you
kind
of
like
a
multiplexer.
If
you
like,
no
matter
which
reportable
you're
talking
you
will
get
yet
so
now,
let's
write
that
sounds
like
it's
really
kind
of
like.
Besides
the
function
level,
it's
not
you
know
API
get
way,
but
but
actually
we
are
much
more
than
they.
B
So
you
really
really
need
to
make
sure
that
you
will
be
able
to
control
it,
and
you
know
to
make
sure
that
there's
no
errors
and
so
on
and
in
order
to
do
that,
it's
better
just
to
automate
all
these
processes.
So
one
of
the
most
important
thing
for
us
is
to
discover
everything
automatically
and
continually
force
discovery,
which
means
that
you
all
didn't
know
what
happening
and
we
we
actually
translated
to
an
invoice
called
by
that.
B
So
we
have
twin
level
discover
the
first
one
is
infrastructure,
so
we're
discovering
every
French
might
those
infrastructure
that
exists
either?
Is
micro
service
or
OpenStack,
Amazon,
Web,
Services
or
Google
or
VMware,
and
we
even
discover
and
what's
special
about
the
terraform?
Is
that
if
we
discover
we
can
actually
know
what
is
the
part
of
the
application
that's
running
on
it,
which
is
really
really
special?
The
other
thing
is
that
we
discovering
every
other
platforms
that
exist
on
top
of
it,
so
either
kubernetes
or
you
know
an
opposite,
then
all
the
rest.
B
So
a
lot
of
like,
for
instance,
we
have
a
customer
that
running
you
know
on
vmware,
but
most
of
this
application
is
Java
using
swagger,
so
we
promote
eclis,
discover
everything
that
exists,
and
this
is
knowledge
this
is
this
is
this
is
with
help
us
for
after
it,
and
I
will
explain
why,
for
instance,
because
we
know
this
the
signature
we
can
prevent
DDoS
attack.
We
can
do
a
lot
of
magic
because
we
kind
of
like
we
are
not.
B
You
know
there
is
a
proxy
level
3,
for
there
is
a
proxy
level
Sam
and
we
kind
of
like
on
top
of
it,
becomes
like
looking
inside
and
making
some
done
when
running
an
AWS
function,
we're
already
putting
the
signature.
Thapa
me,
as
you
can
see,
you
shouldn't
as
a
client.
I
didn't
need
to
do
anything
besides
that.
You
also
discover
all
the
service
function,
because
that's
kind
of
easy,
it's
a
REST
API
call.
We
can
get
all
the
information
and
so
on
so
three
level
function
again.
B
The
point
is
that
let's
finally
discover
as
much
as
we
can
and
use
this
data
we
also
running
on
n
voice,
so
I
mean
anyways.
Like
is
a
perfect,
because
every
is
exactly
built
for
this
ecosystem.
They
did.
You
know
they
did
the
craziness
of
the
micro
services
and
by
the
way
it
was
building
specifically
in
lis,
or
they
had
to
move
from
analytic
to
micro
services.
That.
A
B
Main
purpose
and
it's
Oh
speedy,
CN
CF,
it's
written
beautifully
and
it's
really
really
extensible
in
the
right
place.
He's
again,
it's
like
it's
really
important,
because
if
someone
using
nginx
and
putting
some
control
plan
on
top
of
it,
the
problem
is
that
it's
not
really
inside
a
proxy.
So
it's
really
hard
for
him
to.
You
know
to
prevent
stuff
like
denial
of
service,
but,
and
we
did
the
design
that
way
that
you
can
actually
create
a
filter,
and
this
builder
will
make
it.
You
know
it's.
B
Basically,
you
are
part
over
anyway,
so
you
can
actually
make
sure
you
have
a
lot
of
control
and
it's
what
run.
As
you
can
see
by
a
lot
a
lot
of
organization,
that's
supporting
input
actually
and
running
it'll
a
for
production
for
a
long
long
time
in
crazy
scale.
So
it's
really
there.
For
my
opinion,
the
best
proxy
exists
today,
but
we
didn't
stop
there
because
a
lot
of
people
taking
and
for
inputting
some
control
plan.
B
There
is
nothing
special
about
it,
but
we
actually
took
it
or
asked
to
actually
invest
in
actually
extend
Android,
you
specifically
to
focus
on
our
function.
So,
besides
getting
every
angle,
feature
totalization,
education
in
traffic
control
and
analytical
monitoring
and
logging,
we
also
wrote
a
lot
of
filters
and
so
they're
not
easy
to
write.
It's
like
a
super
fast
icing,
but
we
did
dough
and
we
feature
that
we
open
source
by
solo.
B
We
did
everything
function,
level
routing,
so
we
created
a
base
fielder
that
basically
can
reuse
and
transform
everything
to
work
on
the
function
map.
We
created
a
lot
of
service
and
filter,
one
toy
was14,
Google,
bonkuraazu
and
all
the
others
on
solution,
and
we
did
a
transformation.
Video,
as
I
said.
B
This
is
the
strongest
and
the
most
important
filter
that
we
created,
and
the
reason
is
because,
as
I
said,
it's
using
this
as
the
transformation
we
make
sure
that
we
mean
that
it's
making
us
to
be
a
real
multiplexer,
but
more
than
this,
it's
also
a
validation.
Sir,
a
filter,
if
you
like
to
think
about
that
way,
and
we
can
prevent
DDoS
attack
and
a
lot
of
other
stuff,
because
we
know
the
signature
and
we
have
this
transformation
filter
that
know
how
it
should
look.
B
We
created
a
filter,
we
created
a
project
called
squash
that
I
will
actually
demo
in
a
same
few
minutes
time.
We're
not
going
to
go
to
it
too
much,
but
it's
the
ability
to
actually
a
debug
to
real
debug
like
a
touch
debugger
at
your
micro
services
or
anything
actually
running
on
production,
inner
in
service
mesh
and
then
nuts
filters.
So
it
was
really
important
to
us
to
basically
bring
event.
Do
you
know
to
a
to
the
other
ecosystem
of
the
you
know
of
micro,
citizen
and
and
monolithic?
So
what
we
did?
B
We
basically
chose
nuts
for
now
to
beginning
and
again
it's
really
really
hard
a
filter,
because
it's
translating
HTTP
requests
to
TCP
requests,
but
what
is
giving
us
is
first
of
all,
we
can
deal
with
crazy,
crazy
scale.
Right
now
is
emails
fed
out.
It's
giving
us
persistent,
give
us
a
lot
of
very,
very
strong
tooling,
because
we
don't
think
is
great
great
thing
and
not
just
by
the
way
part
of
the
ciencia
and-
and
the
last
thing
is
that
we
also
have
one
of
them.
B
Is
the
caching
I
think
that
it's
really
really
important
specifically
when
we
gluing
environment,
like
in
a
cloud
provider,
so
as
I
mention
that
I
can
actually
catch
the
requests
to
AWS?
Now
I,
don't
need
to
pay
them.
This
is
you
you
right
so
created
a
three-level
func,
a
caching
caching
inside
and
boy
caching,
in
Redis
and
cashing
in
G
OPC,
and
we
also
did
a
lot
of
filter
on
the
level
of
the
security
better
created
some
dos.
We
did
squashing
we'll
talk
about
it.
B
B
Installer
for
for
a
kubernetes,
all
open
shapes,
and
we
also
created
a
tool
that
will
help
us
to
build
it.
Commodities
doing
is
basically
can
build
envoi
and
build
glue,
can
do
them
separately
and
can
also
build
and
install
their
their
supporting
features
in
that.
Maybe
you
want
us
to
deploy
that
for
you,
so
this
is
again
an
open-source
tools
that
we
created,
but
we
didn't
you
know,
but
still
we
need
to
manage
that
somehow
and
I
think
what's
special
about
our
design
is
our
extensible.
It
is
and
how
really
it's
integrated
with
infrastructure?
B
It's
not
not
for
it's
for
real
the
way
to
actually
working.
There
is
three
parameter
that
we
care.
One
of
them
is
the
secret.
The
other
one
is
auto,
discovering
the
arrow
and
the
last
one
is
user
configuration
for
secret
we're
supporting
right,
now,
evolve
and
see
all
these
in
OpenShift
or
om
a
kubernetes.
All
the
discovery
I
show
you
how
much
we
discover
before
and
use
a
configuration
we
basically
using
the
storage,
because
we
are
stateless
of
either
console
OpenShift
or
just
a
Yama
file.
B
So
what
glue
is
doing
is
basically
watching
it
that
it
is
watching
this
tree
thing
and
then
something
happened
and
you
wanted
them
change
and
go
getting
all
the
information.
It
doesn't
know
anything
it
really.
Don't
you
just
sending
it
to
the
plugin
and
the
plugins.
There
is
a
lot
of
plug-in
a
dead.
B
Looking
at
this
and
they
taking
the
piece
that
relevant
to
them
and
they
basically
translate
it
to
an
end
void,
figuration
they
bringing
are
getting
all
the
data,
creating
the
configuration
and
be
using
the
invoice
VT
or
API,
which
means
that
it's
all
confined
to
your
PC,
very
secure,
very
quick.
You
saw
that
in
the
demo
and
basically
it's
kind
of
watching
us
and
then
it's
getting
the
configuration
and
we
all
set.
So
this
is
basically
the
advantage
of
this
one
is
that
right
now
we
wanna
add
a
new
feature.
B
For
instance,
we
don't
need
to
change
group
whatsoever.
The
only
thing
we
need
to
do
is
to
base
it
to
write
a
plug-in
and
maybe
filter,
so
we
don't
have
an
API,
but
basically
what
we
do
have
is
extensible
if
you
think
extensible
language,
and
so
that's
that
so,
okay,
so
now,
let's
go
back
to
the
demo.
Now
I
think
we
kind
of
like
understand
that
you
know
what
are
you
actually
did
in
the
demo,
so
we
want
to
do
an
ibid
up
right,
and
this
is
how
it's
working.
So
now.
B
B
Okay,
so
that's
great
that's
awesome!
Now
we
can
do
that,
but
wait.
So
now
we
have
this
tree
application
that
built
from
three
different
type
of
application.
The.
What
are
we
supposed
to
do?
Are
we
supposed
to
actually
metrics?
You
know,
collect
the
metrics
in
three
different
places:
oh
look
at
the
log
in
different
technology
or
any
other.
What
this
stuff
doesn't
make
a
lot
of
sense.
So
we
need
to
fix
that,
and
this
is
the
way
I
see
the
echo
system
right.
B
There
is
no
oolitic
micro
service
in
several
eyes,
and
this
is
the
tooling
that
usually
people
use
but
start
with
the
matrix.
There
is
primitives.
There
is
cloud
watch
in
there
in
that
example,
an
APM
but
think
about
it.
We
are
actually
invoking
every
function
that
exists
in
this
echo
see
in
this
application.
We
each
mean
that
we
need
it
for
my
WS,
for
instance,
so
what
we
do
in
basically
created
a
service
that
every
10
minutes
of
fury
this
is
configurable,
is
going
and
sucking
the
right
information
and
bringing
it
all
to
one
place.
B
So
right
now,
it's
per
media,
but
to
be
fair,
we
don't
care,
it's
gonna,
be
that
whatever
you
whatever
matrix
tool
you
want,
we
will
be
able
to
fill
the
information
they're
sending
with
open
tracing,
and
this
is
actually
more
interesting
so
think
about
it.
Think
about
a
span
of
opens
tracing,
but
this
you
know
they
might
did
the
pieces
they're
on
the
spam
are
actually
from
different
type
of
application.
B
There
are
not
only
micro
services
that
could
be
a
function
in
monolithic
and
function
in
micro
services
and
service
function,
so
again
we're
taking
everything,
and
we
sucking
all
the
one
place
that
the
user
can
actually
have
a
real
kind
of
like
give
you
for
everything
in
debug.
We
actually
know
it
is
before
we
even
started
working
on
it.
There
is
a
problem
already
right,
debugging,
it's
actually
micro
service
isn't
really
a
hard
problem.
B
B
Micro
services,
we're
giving
you
all
the
structure
for
that
now
we're
talking
about
deployments
so
yeah
I,
don't
really
want
you
to
go
to
create
different
deployment
tools,
but
you
really
need
to
do
is
to
create
sounds
like
something
that
you
can
think
about
like
an
amateur
like
an
elm
for
cross-platform
ONC
before
post
platform.
So
this
is
something
that
we
will
and
the
other
thing
if
I
wanted
to
test
right
now.
What
I
really
want
to
do
is
I
want.
You
know,
I
want
some
framework.
B
I
mean
it's
really
going
to
be
great,
when
I
will
do
the
canary
deployment
blue-green
and
so
on,
but
before
that,
what
I
want
to
make
sure
is
that
it's
actually
working.
We
we
wrote
a
framework
that
basic
running
this
with
the
monolithic
application,
then
running
it
with
the
same
function
within
their
micro
services
and
Dennis,
sir,
that
you
getting
the
same
result.
So
even
before
you
deploying
they
just
verify
that
you
have
a
firm
over
there
working.
So
that's
that
tonight
show
a
quick
demo
of
squash.
B
B
The
squash
is
one
of
the
example
of
the
things
that
we
build
in
order
to
kind
of
like
make
sure
that
you
can
clue
this
so
okay.
So
this
is
a
micro
service
application
that
I
wrote.
It's
really
really
simple:
it's
basically
getting
two
parameters
and
then
either
add
or
subtract.
So
I
just
put
one
number:
it
doesn't
really
matter
which
one
and
just
do
calculate
what
you
can
do
to
see
that
it's
not
working
because
ninety
one,
ninety
nine
plus
eleven,
it's
not
88.
B
So
what
people
usually
doing
when
that's
happened,
I
will
tell
you
what
they
do:
they're
printing,
because
they
have
no
other
way
to
do
that.
Debugging
is
not
something
that
people
doing
in
micro
service,
doing
it:
monolithic
application
in
micro
service
they
taking
blogs
and
they
troubleshoot
it.
So
if
the
running
is
the
development,
they
can
just
go
to
the
code
and
they
say
this
a
command
and
you
know
and
open
a
shift
and
then
they
will
look
too
long.
B
If
they're
running
production
even
more
a
little
bit
complicated
to
probably
use
something
like
open
tracing
and
then
they
will
need
to
wait
until
10
minutes
until
their
logs
is
aggregated
and
then
ever
try
to
troubleshoot
it.
So
we
think
that
it
can
be
better.
What
we
did
besides
getting
excited
about.
The
new
version
is
we
created.
Basically,
this
is
them
the
micro
services,
a
application
that
we
wrote.
It's
really
simple:
it's
basically
serving
the
HTM
and
it's
reading
in
go
right.
Now
you
can
see
it
in
M
in
a
visual
studio
card.
B
Basically,
it's
getting
the
2.0
matter
that
someone
is
printing.
Then
it's
sending
it
to
a
different
micro
services.
Here.
Reading
in
Java,
you
can
see
very,
very
simple,
running
gear
and
IntelliJ
showing
IntelliJ,
and
what
you
can
see
is
that
the
only
thing
that
is
doing
is
basically
taking
the
two
parameter
that
got
from
the
goal:
microservices,
adding
or
subtracted
and
returning
the
value.
So
now
what
we
did
is
basically
created
an
extension.
B
So
when
you
actually
create
eddying
control/command
chips,
when
you
write
can
actually
get
some
c'mon
so
squash,
the
bug
container
is
the
one
that
google
choose
for
now
and
when
you
can
see
that
it
went
to
the
open
shape
and
basically
suck
all
the
pods
that
running
that
I
can
see.
Okay,
so
I
choose
one
of
them,
the
first
one,
for
instance,
because
it's
service
one
right
and
then
he
tell
me
look
there
was
one
container
in
this
ER
in
this
pod.
Do
you
want
to
debug
it?
B
Let's
do
the
same
thing
right
now
in
the
other
ID
micro-services
stained
pink
squash,
debug
container
again
and
bring
all
the
list
of
the
pods
I'm
going
to
teach
you
the
service
to
in
that
case
and
I
will
take
the
container
they're
running
inside
of
it
and
I
will
attach
the
Java
debugger,
because
that's
why
the
code
is
good,
okay,
cool!
So
now
the
only
thing
that
I
really
need
to
do
is
go
back
to
my
application
and
send
the
calculator
again.
What
do
you
see?
B
Is
them
I,
seriously
debugging
right
now,
life
in
AWS,
so
I
can
go
inside
what
will
happen
without
with
actually
next
jump,
so
we'll
jump
to
the
other
micro
services
right
and
you
can
see
it's
just
working
I'm
coming
here
and
I'm
continue,
and
you
can
see
that
ops,
1,
equal
99,
that's
correct!
You
continue
ops
2
is
equal,
11,
again
correct,
easier
that
equal
true,
it's
all
correct,
but
look
what
I
did
here.
I
specifically
introduced
value.
I
did
that
is
that
a
true
I
want
you
to
do,
but
this
is
a
debugger.
B
So
let's
just
change
it
on
runtime
to
false,
changing
false
I'm
going
to
continue
it.
It
will
jump
back
here
because
they
put
a
breakpoint
and
I
will
continue
it
here,
and
you
discover
is
that
that
fix
the
power
so
again,
very,
very
simple
way
to
do
that.
We
also
created
the
filtering
envelope
for
that,
and
what
happening
is
that
once?
Basically,
there
is
a
lot
of
500
caramel
error
or
something
like
this.
We
can
actually
shatter
the
request
outside
the
class
there
and
basically
start
debugging
it
there.
B
B
Okay,
so
so
basically,
I
mean
basically
there's
no
one
do
to
just
summarize
what
we're
doing
so.
We
doing
very
well
I
mean
we
talking
a
lot
of
conference.
The
open
source
community
love
us,
which
is
fantastic
fantastic
for
us.
They
really
like
it.
We
we
working
with
the
community
for
a
long
long
time
and
it's
really
great
to
be
part
of
it.
B
B
A
We've
got
some
echo,
yes,
Michael
yeah.
We
just
turn
off
some
extra
speakers.
Oh
I,
think
I
think
you've
just
done
probably
the
best
presentation
explaining
the
value
proposition
for
server
list
that
I've
seen
so
far.
Lots
of
other
people
have
talked
open,
Wisc,
open,
foz.
You
know
I've
heard
all
kinds
of
talks
over
the
past.
You
know
six
to
seven
months
that
this
has
been
really
taking
off
and
I.
A
Think
that
one
of
the
things
that
that
people
don't
realize
it
is,
you
know
you
talk
about
the
Big
Bang
and
the
different
architectures
is.
Is
that
how
much
effort
goes
into
lifting
and
shifting
those
legacy
things
and
not
getting
the
benefit
out
and
I?
Think
you've
shown
us
really
how
you
can
get
the
benefit
by
using
this
the
serverless
frameworks
and,
and
some
of
your
tooling
so
I
really
appreciate
that
it's
a
month.
B
A
A
This
is
awesome
and
I
think
the
you
know,
especially
the
the
extension
of
envoi
and
using
that
is
really
very
important
to
a
lot
of
our
our
user
base.
We're
taking
look
at
how
they
can
move
and
take
advantage
of
these
frameworks.
So
it's
really
wonderful
to
see
this.
Take
off
so
fast
as
it
is
I
know,
you're
off
to
dr.
Cohn.
Now
you.
A
You
will
all
be
looking
forward
to
that.
There's
also
your
said.you
based
in
Boston
there's
a
surrealist
track
in
a
small
conference
called
dev
comp
us
in
August
that
I'll
send
you
some
information
too,
as
well,
because
I
think
this
would
fit
in
really
nicely
with
some
of
the
stuff
that
they're
talking
about
there
as
well.
So
and
not
that
one
you
won't
have
to
travel
for
so
yeah.
That's
great
I,
don't
see
any
questions
in
the
chat,
so
I
think
you've,
maybe
given
them
so
much
to
think
about
that.
I
have
to
go
back.
B
A
And
I
think
this
is
going
to
be
a
big
part
of
the
next-gen
of
where
we're
going
to
is
the
whole
operator
framework,
so
mm-hmm
we'll
definitely
have
more
on
the
operator
framework
coming
up
soon
and
other
openshift
Commons
briefings
so
we'll
have
you
back
and
I'm
really
interested
in
seeing
how
you
know
like
we
have
a
docker
registry.
You
know
that's
how
we
get
all
of
these
operators
that
are
all
over
the
place
into
some
way.
B
A
Yeah
I
haven't
I,
haven't
seen
it
exactly,
but
I
think
that's
when
what
I'd
love
to
see
is
to
get
all
the
people
from
Couchbase
to
you
to
Brandon
together
to
talk
about
how
to
build
these
operators,
how
to
use
the
SDK-
and
you
know,
feedback
on
all
of
that
and
get
that
that
conversation
rolling,
because
there's
lots
of
other
things
that
we
need.
Operators
yeah.
B
A
B
A
A
There
all
right,
perfect,
that's
a
great
way
to
end
good
luck
with
your
keynote
at
dock.
Work
on
will
be
listening
in
and
remotely
concerned,
not
turn
them
I'm
trying
not
to
travel
this
month,
there's
enough
to
go
through
next
month
and
hopefully
we'll
see
you
in
Boston
sometime
soon
yeah.
Thank
you
all
right.
Take
care
and
thank.