►
From YouTube: gRPC July Meetup/ How to configure Istio to support your gRPC web applications- by Casey Wylie
Description
gRPC comes loaded with benefits including portability, speed, and efficiency, yet the configuration of the mandatory proxy for translating between gRPC-Web requests and HTTP/2.0 in the browser is still a major pain point for many. During this presentation Casey Wylie will cover a deep dive of how to configure Istio to support your gRPC web applications that consume streams.
A
So
I'm
casey,
I'm
an
engineer
at
solo
and
before
we
start
the
the
process
today
is
actually.
There
is
a
link
to
a
repository
if
you'd
like
to
visit
it
and
kind
of
follow
along
and
basically
at
the
end
of
this
chat.
I'm
gonna
have
a
demo,
and
during
this
demo
I'm
going
to
show
you
guys
how
to
install
istio,
for
the
sake
of
simplicity,
we're
going
to
install
install
istio
using
the
demo
profile
from
there
we're
going
to
actually
go
ahead
and
create
the
gateway
we're
going
to
create
a
virtual
service.
A
So,
let's
get
into
it.
As
far
as
the
chat
agenda,
I'm
going
to
give
you
guys
a
very
small
background
on
grpc.
I
know
more
than
likely
that
most
people
are
very
familiar
with
it,
but
just
in
case
there
are
some
people
that
are
less
familiar
with
it.
We're
going
to
go
into
the
problem
statement
with
grbc
web
and
specifically
using
http
2.0
in
the
browser.
A
The
next
thing
we're
going
to
talk
about
is
a
solutioning
demo
overview
and
I'm
going
to
chat
with
you
guys
and
everyone
actually
about
an
application
that
I
built.
The
front-end
is
a
is
a
react
app,
it's
actually
using
grpc
web,
it's
using
the
devtools
and
the
back
end
is
a
normal
go
application,
that's
implementing
the
grpc
streaming
and
next
we'll
configure
istio.
I
have
a
nice
script,
that's
very,
very
simple
and
it's
very
easy
to
actually
stand
still
up
in
the
cluster.
A
It
doesn't
doesn't
take
very
long
and
I'm
actually
just
going
to
do
that
live
so
I'm
going
to
go
ahead
and
configure
sdo
live
and
deployed.
Applications
live
after
that
I'll
go
into
a
high
level
recap
and
then,
finally,
I
will
finish
with
a
demo
in
my
google
cloud:
kubernetes
environments,
okay,
so
grpc
streams
and
grbc
web
I'm
going
to
get
a
very
small
background
on
on
grpc
stream
types.
A
A
A
A
A
So
this
from
a
very
high
level,
this
is
what
a
grbc
web
application
looks
like
you.
Have
your
grpc
web
application,
that's
running
in
the
browser
outside
of
the
cluster
you
have
in
this
case
you
have
envoy,
but
in
our
case
we
have
the
istio
ingress
gateway
and
then
from
there
the
request
path
is
going
to
go
to
the
backend
service.
That's
requested
in
this
case.
It's
a
grpc
streaming
web
application,
so
the
grpc
web
client
will
connect
to
envoy
will
connect
to
the
backend
services
via
enboy
onboard
is
going
to
facilitate
that
that
connection.
A
A
So
that
is
a
continuous,
a
continuous
connection
right,
http
1,
the
connection
opens
and
closed
in
http
2.
The
connections
stay
opened.
If
you
want
an
example
of
this,
let's
start
thinking
about
things
like
websockets
grpc
streams,
the
connection
stays
open
and
it's
a
much
more
efficient
prototyl
protocol
in
terms
of
transferring
and
sending
data.
A
So,
if
we're
actually
looking
on
grpc
web's
website,
we
can
actually
see
that
they
have
specified
us
with
an
envoy
config.
So
this
is
actually
a
a
concatenated
version
of
the
of
the
envoy
config.
But
if
you
know,
envoy
envoy
is
actually
somewhat
simple
right,
it
actually
shows
the
the
requests
and
the
paths
we
can
see.
We
have
a
prefix
here
we
can
see
which
what
our
target
endpoint
is,
in
this
case,
it's
a
greeter
service.
A
In
my
case,
it's
a
it's
called
a
back-end
service,
but
the
really
important
parts
here
are
grpc
web's
website
their
documentation
gives
us
the
exact
headers
that
need
to
be
passed
to
envoy.
In
order
for
it
to
facilitate
this
connection,
and
those
headers
are
dll
headers,
you
have
to
have
to
keep
alive
the
cache
control.
A
So
this
is
the
poc
solutioning
overview.
If
I
was
just
talking,
it
would
be
at
least
the
way
I
learn
is
a
hands-on
way.
So
that's
why
I
wanted
to
give
you
all
something
that
you
can
play
with
yourselves.
So
you
can
decide
for
yourselves
if
this
is
a
way
that
would
satisfy
your
own
use
cases-
and
I
this
is
a
very
tried
demo-
I
haven't
got
it
to
fail
yet,
but
most
likely,
my
first
failure
will
be
during
this
live
demo,
but
high
level
overview.
A
A
You
know
grpc
streams
due
to
the
fact
that
you
have
a
protobuf,
so
if
you're
using
a
monolithic
application,
which
is
an
application
that
has
mini
app
or
repository
that
has
many
applications
inside
of
it.
It
makes
the
generating
of
the
protobufs
much
easier,
and
I
actually
have
a
in
the
code
how
you
can
just
use
this
from
a
shell
script
and
it
will
generate
the
code
into
the
react
app
from
the
drpc
streaming
backend.
A
So
in
the
goal
for
this
is
to
have
the
most
simple
use
case
possible,
I
I
don't
want
anyone
to
get
lost
by
a
complicated
protobuf
file.
This
is
a
very
simple
protobuf.
Basically,
the
request.
What
the
client
is
going
to
request
from
the
server
is
they're
going
to
send
a
string.
That's
the
user
agent
right
and
if
you
know
the
user
agent,
it's
like
chrome
things
like
that,
your
user
agent,
but
the
response
is
going
to
be
a
boolean
value.
A
The
second
is
going
to
be
a
time
stamp.
The
third
is
going
to
be
that
same
user
agent
that
the
client
sends
into
the
server
it's
going
to
be
echoed
back,
and
the
fourth
is
going
to
be
a
count
variable
that
will
continuously
increase
over
time
and
we
can
see
our
our
service
numbers.
We
have
just
one
function,
get
numbers
it
takes
in
this
numbers
request,
which
is
a
user
agent,
and
it
returns
a
stream
of
number
responses.
A
So
speaking,
of
go
right,
so
here
is
our
back-end
code,
our
back-end
code
for
the
go
link
application.
Is
it's
an
infinite
for
loop?
This
variable,
I
is
declared
out
of
scope
outside
of
main,
so
it's
initialized
with
the
value
of
zero
in
every
single
iteration
of
this
for
loop
is
going
to
consistently
increase
we're
going
to
be
sending
an
api
number
response
exactly
like
we
were
talking
about
in
the
proto.
A
A
A
A
A
Service.Namespace.Svc.Cluster.Local
right,
that's
how
services
communicate
with
one
another
inside
of
the
cluster
only
that
this
is
a
react
application.
It's
actually
sits
outside
of
the
cluster,
and
this
react
application.
That's
sitting
on
on
the
client's
browsers
is
going
to
have
to
communicate
back
to
the
cluster.
Therefore,
we
cannot
call
our
backend
service
backend.default.sbc.cluster.local
right,
because
our
request
is
going
to
have
to
go
through
the
gateway.
That's
the
only
way
and
it-
and
we
all
know
it's
actually
very
simple-
to
attach-
attach
a
cert
onto
the
istio
ingress
gateway
with
the
http
port.
A
The
next
part,
that's
rather
interesting,
at
least
in
my
opinion,
is
the
enabling
dev
tools
enabling
dev
tools.
This
is
actually
gives
you
a
lot
of
good
information
inside
of
your
web
browser
in
the
chrome
dev
tools.
It's
only
two
lines.
Once
you
install
the
grpc
web
package,
you
can
already
use
it,
so
this
is
going
to
show
you
information
about
your
requests
that
are
coming
in
and
leaving
other
than
that
we
have
this
get
number
stream.
A
A
The
component
is
going
to
display
the
true
or
false
boolean
value,
whether
the
number
is
even
or
odd
the
time
stamp
in
which
the
request
was
originated
in
the
backend,
the
user
agent
that
we
gave
to
the
backend
and
then
the
total
count,
aggregated
of
all
the
requests
that
have
hit
our
application
and
one
more
thing
on
the
front
end.
This
front
end
is
actually
very,
very
basic
right.
A
If
you
have
a
monolithic
repository,
you
can
run
both
of
these
two
commands
to
compile
your
protobuf
from
the
back
end
from
the
from
the
golang
app,
and
this
will
also
compile
the
exact
same
protobuf
app
and
in
my
personal
front-end
I
have
the
protobuf
in
an
api
folder,
and
I
actually
it's
just
a
standard
that
I
I
typically
use
but
the
pro
and
I
didn't
even
come
up
with
this.
This
is
like.
A
These
two
files
that
are
generated
for
you,
the
number
dot
protobuf
and
the
number
jrpc
web
protobuf.
Both
of
these
files
need
this.
Yes,
let
disable
both
of
them
by
default.
Only
one
file
will
have
it,
but
make
sure
you
have
this
line
on
both
of
them
or
you'll,
have
compilation
errors
or
really
interpretation
errors
in
your
front
end,
as
your
front
end
is
interpreting
your.
A
Now,
let's
get
into
the
istio
configuration,
so
we
were
looking
at
the
sdo
configuration
earlier
and
now
our
really
only
job
is
to
just
translate
that
into
onboard
configuration.
I
said
it
was
easy
and
the
reason
I
said
it's
easy
is
because
they
basically
have
the
exact
same
names.
The
istio
configuration
the
envoy
configuration.
A
So
this
seo
configuration
is
an
istio
virtual
service,
and
this
is
just
this
is
a
a
brief
snippet
of
it.
The
full
virtu,
the
full
virtual
service
is
in
the
repository.
The
repository
is
public.
You
guys
can
check
it
check
it
out
play
with
it.
Spin
up
your
own
clusters.
Let
me
know
how
it
works,
but
this
is
actually
the
virtual
service.
A
A
So
here
is
the
the
demo,
the
little
poc,
it's
very
simple,
but
basically
just
four
steps:
we're
going
to
install
istio
using
the
demo
profile.
I
say
this
is
only
for
demo
purposes.
The
reason
I
say
this
is
because
nowadays
istio
says
you
shouldn't
install
everything
in
the
same
name:
space
like
you
should
have
your
ingresses
in
their
their
own,
appropriate
namespaces.
A
Actually,
the
the
latest
actually
says
that
you
should
have
correct
me
from
wrong,
but
I
think
it's
actually,
the
east
west
gateway
in
the
north,
south
gateway
in
different
name
spaces.
But
anyway
it's
a
it's.
A
demo,
app
everything's
going
to
be
in
the
sdo
system,
name
space
and
we
are
going
to
deploy
the
back
ends
and
we're
going
to
deploy
the
front
end
and
then
we're
going
to
create
the
sdo
configuration
necessary
in
the
istio
configuration
as
we're
going
to
install
like
the
world's
simplest
gateway.
A
A
So,
as
in
terms
of
the
repository
itself,
this
is
public
on
github.
I
highly
encourage
you
guys
to
interact
with
it
play
with
it,
especially
if
you
have
any
questions,
but
what
you
can
do
is
we
have
our
our
simple
back-end
service?
It's
just
our
go
service.
It
has
the
ex
exact
same
things
that
we
were.
I
was
showing
you
guys
in
the
slide.
A
And
then
we
have
our
and
here's
our
api,
here's
our
proto
file
and
here's
our
front
end
our
api
folder,
and
then
this
is
our
actual
front-end
application.
This
is
the
only
component
that
we're
actually
using
that's
our
only
smart
component
because
it
actually
gets
the
data.
Here's
how
we
actually
enable
dev
tools.
A
So
this
is
this.
Is
it
next
thing
I
want
to
kind
of
point
out
briefly?
Is
we
have
our
back
in
deployment
our
service?
Our
service
account
we're
not
even
using
the
service
account
right
now.
Our
remember
our
service
is
labeled
grpc
web.
We
have
our
front
end.
Our
front
end
is
deployed
in
the
normal
way
other
than
this
isn't
deployed
behind
nginx
or
any
way
that
you
would
normally
deploy
your
front
end
for
production.
A
This
is
actually
just
I'm
using
npm
run
for
this,
so
I
I
deployed
it
in
a
very
simple,
simple
way:
here's
our
docker
file,
if
you,
if
you're
interested
in
seeing
that
all
right,
so
here
we
go,
I
forgot
to
delete
everything
before,
but
I'm
pretty
sure
this
is
just
gonna
work
out.
Just
fine
all
right.
A
A
A
A
B
C
A
C
Any
and
casey
I
had
a
question:
hey
sure:
yeah
yeah,
thanks
for
up
the
talk
so
far
and
the
demo
code
really
useful.
So
you
mentioned
that
between
the
browser
and
the
istio
proxy,
it's
http
star,
I
saw
you
mentioned.
So
what
exactly
is
the
protocol
there,
because
I
mean
modern
day
browsers.
If
you
I
believe,
if
you
just
talk
over
https,
it
will
default
to
http
group
sort
of
connection
at
least
so
yeah.
Can
you
please
explain
that
a
bit
more
sure.
A
So
the
the
root
of
the
problem
is
actually
that
the
browser
can't
interpret
the
http
2
frames
right,
and
this
is
actually
an
active
development.
There
is,
I
I'm
going
to
butcher
this
name,
but
I
think
it's
called
it's.
This
is
not
what
it's
called,
but
it's
something
like
javascript
scripts.
No,
no!
It's
like
something
streams,
but
with
this
streams,
you're
actually
going
to
be
able
to
force
http
2
in
the
browser.
A
Currently
you
you
can't
force
it,
and
I
I
mean
you
can
probably
try
this
on
your
own
and
sometimes
you
can
get
it
to
work.
If
you,
if
you
have
like
a
local
environment
and
oddly
enough,
I've
had
it
working
with
with
tls
at
times
when
I
actually
give
a
a
cert
and
a
private
key
to
my
applications.
Sometimes
it
works,
but
it's
it's
just
not
consistent.
A
Yes,
yeah:
that's
exactly
what
I'm
saying,
I'm
saying
that
their
browsers
are
going
to
be
unable
to
actually
interpret
the
the
frames
from
htp2.
But,
yes,
that's
exactly
right,
but
if
you're
using
grpc
curl
you're
going
to
have
zero
problems
at
all.
Okay.
Thank
you.
Yeah,
no
problem,
any
other
questions.
A
Great
question
great
question:
sweeney
yeah
envoy
is
highly
highly
dynamic
and
super
highly
configurable
envoy
works
great
with
rest
applications
and,
in
you
know,
in
your
istio
gateway,
for
instance,
to
kind
of
revisit
that
question.
If
we're
looking
at
our
istio
ingress
gateway
or
our
actual
gateway
crd,
we
can
see
right
here.
We
have
one
port
defined,
which
is
an
http
port.
A
A
C
Guess
sorry,
hello,
everyone,
sorry
hi!
Essentially
I'm
saying
that
for
those
layers
in
this
case
it's
because
we
want
to
have
grpc
communication
or
binary
communication
between
the
front
and
back
and
directly
with
the
gear
pc
gateway.
You
will
have
just
the
part
of
the
rest
api
and
actually
generate
those.
You
know
that
extra
transfer
layer
in
there
so
yeah.
A
B
Don't
worry,
okay,
so
does
anybody
else
have
any
questions,
if
not
all
good,
okay
yeah?
So
please
everyone.
If
you
could
complete
the
story
that
will
be
great
and
casey.
Thank
you
so
much.
I
guess
everyone
enjoyed
your
talk
a
lot.
So
thank
you.
Thank
you
for
sharing
all
of
this
with
everyone,
and
I
hope
we
could
have
another
meet
up
anytime
soon.
A
C
A
B
No
worries
also
chauffeur
is
asking
if
there
is
someone
from
google
in
this
meeting,
but
besides
that,
I
would
like
to
invite
everyone
if
anyone
is
interested
on
presenting
a
demo
just
as
casey
just
did,
and
it
was
great
thank
you.
If
anyone
wants
to
present
a
demo,
please
do
not
hesitate
to
contact
us
and
yeah,
because
we
are
all
time
trying
to
find
a
speaker.
Okay.
So
thank
you
again,
everyone
for
joining
us,
and
thank
you
thank
you
for
being
here.
Thank
you.
Casey.
C
E
E
This
is
not
related
to
the
presentation,
but
it's
like
a
general
question
regarding
the
binary
log
in
the
grpc
service,
we're
trying
to
use
this
to
build
a
debugging
platform,
but
it's
just
you
know
very
hard
to
find
any
related
information
regarding
to
the
binary
logging
feature
from
the
jrpc
servers.
So
we're
wondering
what
we
can
do.
How
can
we
get
some
help
on
this
topic?.
D
D
E
D
So
it's
sort
of
both
so
the
classic,
the
classic
c
sharp
was
built
off
of
c
core.
Okay,
it
supports
the
older
net
platforms.
Okay,
the
the
the
there's
a
newer
implementation
built
off
of
net
core
and
the
people.net
people
can
will
say
that
I'm
saying
the
wrong
words,
but
I'm
I
think
that
the
gist
will
be
about
right
and
so
for
the
newer
platforms.
D
E
D
B
D
E
D
Yes,
yes,
the
the
go.
Implementation
should
be
very
easy
for
you
to
find
the
the
java
implementation
is
is
also
available.
The
go
implementation,
though,
whenever
you
look
at
it,
you
were
wanting
to
filter
some
of
the
binary
logging
entries
that
you
were
getting
some
of
the
log
entries
go
will
make
that
very
easy.
Okay,.
C
D
D
E
D
E
D
E
Going
to
be
very
important,
so
we
kind
of
like
want
to
build
something
on
top
of
open
telemetry.
That's
another
effort
from
google.
Previously
I
was
working
at
google
so
actually
aware
of
this
kind
of
effort,
but
okay
anyway.
So
please
reply
the
email
at
your
earliest
convenience
and
we
can
see
you
know
whether
we
can
actually
help
contribute
to
some
of
the
implementation.
There.