►
From YouTube: KubeCon US 2020 - Daily Demo featuring Gloo Edge
Description
Gloo Edge is an Envoy Proxy based API gateway and ingress controller. Check out this quick overview demo by Jim Barton on how to set up routes and manage traffic with Gloo Edge.
A
A
So
we're
going
to
start
with
a
scenario
here
kind
of
depicted
in
this
diagram,
where
we
have
a
a
monolithic
application.
That's
out
there,
it's
a
pet
clinic,
app
you've
very
likely
seen
it
before.
I
think
it
originally
came
out
of
the
java
spring
world.
So
it's
a
it's
just
a
it's!
It's
a
web
app
that
is
java
based.
It
sits
in
front
of
a
mysql
database.
So
it's
a
it's!
A
It's
going
to
be
a
traditional
monolithic
application,
and
so
what
we're
going
to
do
today
is
show
how
we
can
use
glue
edge
to
help
as
part
of
the
transition
process
from
that
monolithic,
app
into
something
that's
based
on
a
microservices
architecture,
and
so
we're
going
to
use
glue
as
the
as
the
gateway
that
allows
us
to
to
enable
that.
So
so
from
this
picture
here
you
can
see
the
pet
clinic
app
it's
running
in
our
in
our
kubernetes
cluster.
A
In
this
case
it's
a
kind
cluster
running
on
my
workstation
here,
although
it
could
be,
it
could
be
gke,
it
could
be
aws,
it
could
be
any
any
kind
of
kubernetes
cluster.
There
are
no
no
restrictions
there,
and
so,
if
we,
if
we
take
a
look
at
at
glue
itself,
it
is
based
on
envoy.
So
it's
an
envoy
based
reverse
proxy,
and
what-
and
so
that's
important
because
envoy
is
you
know
next
generation
in
terms
of
application
enabling
proxies
for
kubernetes?
A
It's
it's,
of
course
what
what
istio
is
based
on,
as
well
as
a
number
of
the
emerging
proxy
technologies.
So
so
envoy
is
a
is
a
filter
chain
based
architecture,
and
so
there
are
a
lot
of
a
lot
of
things
that
we
can
very
easily
connect
to
from
blue
edge.
They
give
us
some
important
gateway
capabilities
so,
for
example,
things
like
external
authorization
using
open
id
specs,
so
we
can
connect
out
to
to
external
security
services
like
like
octa
like
dex
like
off
zero.
A
Like
you
know,
the
list
goes,
the
list
goes
on
and
on
so
so
it's
a
nice
standards-based
way
to
do
external
authorization
and
also
apply
filters
like,
via
with
with
mod
security
web
application
filters.
So
any
set
of
mod
sec
rules
that
you
use
to
apply,
say
protection
rules
for
your
for
your
application
network.
You
can
use
those
here,
but
we
also
bundle
things
like
rate
limiting
services
in
there
and
some
other
things
that
we'll
that
we'll
talk
about
as
well.
A
So
what
we're
going
to
do
over
the
course
of
this
of
this
exercise
is
so
we'll
start
out
with
just
this
web
application
talking
to
the
pet
clinic
monolith
and
then
using
the
capabilities
of
glue,
we're
going
to
we're
going
to
gradually
kind
of
apply
a
strangler
pattern
to
that
monolith
where
we
begin
to
siphon
off
services
from
the
core
pet
clinic
and
put
them
in
other
places.
So,
for
example,
we
will
we
will
take
one
of
the
services
and,
oh,
my
picture
went
away.
A
We'll
take
we'll
take
some
of
those
services,
we'll
siphon
those
off
to
another
microservice
running
in
kubernetes
and
then
finally,
we'll
take
a
we'll
take
a
a
slice
of
the
services
and
we'll
we'll
route,
those
off
to
a
lambda
function,
running
on
aws.
Just
to
give
you
a
flavor
of
what's
what's
available
there,
okay!
A
So
let's,
let's
take
a
look
at
what
we
actually
have
running
in
our
kubernetes
cluster.
So
again,
this
is
a
kind
based
demonstration,
so
we
have
the
pet
clinic
web
application
running
here.
It's
talking
to
a
mysql
database
as
we
as
we
mentioned
before,
and
then
you
can
see
glue
is
installed
here
as
well,
and
so
there
are
a
number
of
elements.
I
just
want
to
talk
about
briefly,
that
are
part
of
the
glue
part
of
the
glue
instance.
A
We
have
installed
here
so
so
there's
an
api
server,
which
is
the
web
server
component
that
serves
up
this.
This
administrative
web
ui
here,
which
we'll
come
back
to
a
little
bit
later,
but
it
it
shows
us
the
current
status
of
the
of
the
various
components
of
glue
and
we'll
come
back
and
talk
about
those
a
little
bit
more.
A
So
this
discovery,
pod
discovery
deployment
enables
that
there's
also
external
authorization,
as
we
talked
about
a
little
bit
before
so
being
able
to
delegate
off
to
to
external
security
services
to
to
to
to
authenticate
and
authorize
your
users,
the
gateway
proxy
itself.
Here
this
is
actually
the
data
path
for
your
request.
So
this
is
where
the
envoy
proxy
actually
lives
inside
here,
and
then
there
are
a
couple
of
components
that
manage
the
configuration
of
that
gateway
proxy.
A
So
it's
it's
very,
very
nice
when
you're
thinking
about
getting
ready
to
go
to
production
and
you'd
like
to
be
able
to
specify
your
components
in
a
in
a
cloud-native
way.
You
know
you
don't
want
to
have
to
you:
don't
want
to
have
to
spin
up
an
external
database
or
anything
like
that.
You'd
like
to
be
able
to
express
your
components
in
a
cloud-native
way,
using
kubernetes
custom
resources
and
then
have
those
stored
using
native
kubernetes
fcd
mechanisms.
A
A
There
are
also
integrations
with
a
number
of
components
for
for
visibility,
for
metrics
of
prometheus
grafana,
that
sort
of
thing
or
you
can
integrate
with
your
own
instances
if
you'd
like,
but
we
do
provide
you
with
something
out
of
the
box
for
that
as
well.
Okay.
So
it's
just
a
quick
tour
of
what's
actually
running
inside
the
inside
the
glue
installation
here.
So,
let's,
let's
actually
start
building
out
some
things.
A
A
It's
a
very
simple
one
at
this
point,
so
we're
we're
for
this
virtual
service,
we're
targeting
any
domain
for
a
request
that
comes
in
and
then
we
have
a
single.
We
have
a
single
route
matcher
here,
so
basically
any
prefix
that
comes
in
we're
going
to
take
that
and
we're
going
to
route
that
to
this
pet
clinic
upstream
that
we
just
that
we
just
talked
about
a
minute
ago.
A
So
if
you
take
a
look
at
the
application
itself,
here's
the
here's
the
home
and
you
can
see
there
are
a
couple
of
services
that
we
have
deployed
in
this
in
this
monolithic
app.
We
can
search
for
owners
that
are
associated
with
our
pet
clinic,
and
we
also
have
a
list
of
veterinarians
here
that
and
their
and
their
specialties,
and
if
we
take
a
look
at
this
contact
page
well,
there's
something
wrong
here.
There's
an
error!
That's
popping
up!
A
And
so
what
we'd
like
to
be
able
to
do
is
to
provide
some
more
information
with
these
vets
as
well,
and
we
don't
want
to
do
this
by
going
in
and
modifying
this.
This
monolith-
that's
already
sitting
out
there,
we'd
like
to
begin
to
to
strangle
that
monolith
and
begin
to
provide
these
services
via
via
microservices,
and
so,
let's
take
a
look
at.
A
Let's
take
a
look
at
vs
code
here,
so
here's
the
here's,
the
virtual
service
we
already
have
in
place
where
everything
is
routed
to
the
monolith
and
then
there
there
are
a
couple
of
other
things.
We
want
to
do
with
this,
so
so
the
first
thing
is
this:
is
this
is
the
actual
microservice
itself,
so
you
can
see
there's
a
there's,
a
deployment
here
with
this,
with
this
microservice
there's
the
service
associated
with
this.
This
is
just
standard.
You
know
standard
kubernetes,
stuff,
there's
nothing
special!
A
That
glue
is
doing
here,
but
then
what
we're
going
to
do
on
top
of
that
microservice
deployment
is
we're
also
going
to
modify
our
virtual
service.
So
you
might
remember
this
particular
matcher
was
there
in
the
beginning,
and
so
this
is
kind
of
our
catch-all
route
that
takes
you
know
any
any
request
that
comes
in
and
routes
that
to
the
the
pet
clinic
monolith,
and
so
now
what
we're
going
to
do
is
we're
going
to
ahead
of
that
in
the
in
the
route.
A
A
If
we
apply
this
so
now
we
can,
our
virtual
service
has
been
configured,
but
we
look.
You
know
we
got
a
problem
here
right.
We
have
a
problem
in
that
our
our
upstream
isn't
found,
and
so
the
glue
administrative
ui
is
is,
you
know,
is
pointing
that
out
to
us,
hey,
you
got
a
problem.
There's
an
upstream,
that's
being
specified
in
a
virtual
in
this
virtual
service.
That's
not
found!
Well
that's
because
we
did
things.
We
did
things
out
of
order
right.
A
A
We'll
apply
this
this
microservice
and
you
can
see
here
in
canines.
You
can
see
that
microservice
is
actually
spinning
up
for
the
first
time
in
our
cluster
and
so
we'll
give
that
just
a
second
and
then
once
that's
running,
we
can
go
back
to
our
administrative
ui.
You
can
see
our
service
status
is
now
green
right
because
there's
no
more
there's
no
more
reference
to
an
upstream
that
doesn't
exist
anymore,
everything's
there,
and
now,
if
we
go
back
to
our
user
interface,
you'll
notice.
A
This
is
our
before
picture,
where
we
had
a
list
of
vets
with
kind
of
two
sets
of
information,
and
when
we
refresh
this
you'll
see
now
we
also
get
the
the
location
of
the
vets
as
well
so
what's
happening.
There
is
this
request
to
vets
right
right
here
is
being
intercepted
by
blue
edge,
and
the
request
is
being
routed
to
this
new
microservice
that
we've
deployed,
without
disrupting
the
the
monolith
that
that
sits
behind
and
provides
the
remainder
of
the
services.
A
A
A
So
so,
let's
assume
that
in
our
world
we
have
built,
we
have
built
a
lambda
service
in
aws
and
that
lambda
service
actually
provides
this
contact
form
and
stores
the
information
off
and
that
sort
of
thing
so
can
we
use
this
same
interface
and
route
to
yet
another
service
that
will
provide
this
missing
contact
form.
So
good
news
is
we
can
do
that.
A
A
We've
gone
out
and
simply
basically
interrogated
this
with
our
with
our
aws
user
id,
and
so
you
can
see
there
are
a
whole
bunch
of
lambda
services
that
are
available
here
on
this
particular
aws
account,
and
so
we're
actually
going
to
just
pick
the
one
of
these
that
does
what
we
wanted
to
do,
which
is
this
guy
right
here.
This
contact
form
version.
Three
is
the
lambda
service
that
we
want
to
that
we
want
to
route
to
from
glue.
So
let's
go
take
a
look
at
our
virtual
service.
A
A
That
and
it
might
help
if
I
apply
the
you
you'll
notice,
you'll
notice,
what
it
says
there
was
that
our
virtual
service
was
unchanged.
That's
because
I
I
fat
fingered
it.
If
we
go
and
add
the
correct
the
correct,
modified
microservice,
then
you
can
see
it
actually
will
indicate.
This
has
been
configured
you'll
notice
here.
A
Also,
it's
very
important
that
you
that
you
stack
these
matchers
in
the
correct
way
so
order
matters
here,
and
so
that's
why
we
have
the
contact
prefix
and
the
vet
prefix
matchers
first,
and
then
we
have
this
catch
all
at
the
end.
If
we
put
the
catch
all
at
the
beginning,
then
these
these
particular
matchers
would
never
be
reached.
So
it
is
important
to
to
pay
attention
to
ordering
here,
but
our
virtual
service,
our
virtual
service
chain,
should
have
been
applied
now.
A
So
if
we
go
take
a
look
at
this,
the
owners
are
still
okay.
The
vets
are
still
showing
three
columns
and
the
the
contact
now
is
actually
showing
a
proper
contact
form
and
not
and
not
throwing
an
error.
And
so
what
we've
been
able
to
do
using
glue
is
we've
been
able
to
assemble
these
kind
of
three
very
different
underlying
resources?
A
B
B
Let's
see.
Let
me
just
get
this
link
for
y'all
glue
is
something
glue.
Etch
is
something
that
we
have
available
open
source
as
well
as
enterprise
and
then,
if
you're
interested
in
the
enterprise
trial,
which
comes
with
so
enterprise,
has
added
security
and
management
federation
type
capabilities.
That
stuff
is
here.
If
you
want
to
get
started,
trying
the
traffic
management
traffic
shaping
and
all
that
that's
all
available
in
open
source,
and
let
me
get
one
more
link
for
everyone-
we've
hosted
a
lot
of
the
core
glue.
B
A
B
A
B
Again
there
you
go
and
then
we
do
have
live
online,
instructor-led,
hands-on
workshops
coming
for
your
european
time
zone.
They
are
there's
one
in
november
and
there's
one
in
december
and
then
for
u.s
time
zone.
We've
got
two
coming
in
at
the
end
of
january,
so
you
know
opportunities
to
kind
of
just
get
deeper
into
the
into
glue
edge
and
then
kind
of
try
some
of
the
workflows
yourself,
that's
it!