►
From YouTube: T-Mobile Store Locator Serverless Journey with Knative and Kubernetes - Ram Gopinathan, T-Mobile
Description
Join us for Kubernetes Forums Seoul, Sydney, Bengaluru and Delhi - learn more at kubecon.io
Don't miss KubeCon + CloudNativeCon 2020 events in Amsterdam March 30 - April 2, Shanghai July 28-30 and Boston November 17-20! Learn more at kubecon.io. The conference features presentations from developers and end users of Kubernetes, Prometheus, Envoy, and all of the other CNCF-hosted projects
T-Mobile Store Locator Serverless Journey with Knative and Kubernetes - Ram Gopinathan, T-Mobile
This talk will cover T-Mobile's serverless journey with the recently announced Knative project. The session will go into depth on how build and serving components of Knative project is leveraged to deliver store locator experience which consists of two functions indexing and query. Query function leverages geo distance search query capabilities provided by elastic search which is also deployed on kubernetes
To learn more: https://sched.co/GraC
A
My
name
is
Sarah
ROM
go
P,
Nathan,
I'm,
a
full-stack
engineer
with
22
plus
years
of
software
development
experience,
but
Google
and
Java
developer.
If
it's
not
obvious,
I
work
for
t-mobile,
so
just
a
level
set
a
few
things.
This
talk
is
not
about
what
K
native
is
and
all
the
features.
It's
just
simply
to
talk
about
a
use
case
that
we
picked
a
real-world
enterprise
use
case
that
we
picked
as
we
went
through
the
journey
of
test
driving,
K
native
features
way
back
in
summer.
A
What
I
want
to
do
next
is
basically
just
kind
of
go
over
like
our
motivation,
why
did
we?
Why
did
we
start
looking
into
K
native
the
next
few
slides
I'm
going
to
take
some
time
to
kind
of
give
you
guys
a
context
so
before
I?
Do
that
you
know
as
a
team,
we
are
at
a
higher
level
without
going
too
deep
into
the
details.
There's
like
two
category
of
development
I
mean
teams
that
we
have
in
our
in
our
company.
One
is
platform
service
providers.
A
We
have
both
platform
service
providers
for
workloads
that
run
on
premises
and
in
the
cloud
as
well,
and
we
run
pretty
much
our
you
know
on
all
all
three
clouds
for
variety
of
reasons
which
I
won't
go
too
deep
into,
and
then
the
second
class
of
category
of
developer
I
mean
they're
groups
that
I
call
enterprise
developers
what
they
do
is
they
build
and
ship
products
that
are
used
by
our
customers.
It's
a
few
examples
include
our
website:
t-mobile
comm,
our
mobile
apps,
that
customers
use
both
Android
iOS
and
other
platforms
as
well.
A
A
Basically,
they
want
to
focus
on
writing
the
business
logic.
They
don't
want
to
learn
about
how
to
run
the
kubernetes
infrastructure,
how
to
operate
it.
They
want
to.
You
know
you
have
your
source
code
in
your
repository.
You
want
to
be
able
to
get.
You
know
as
I
commit
changes
to
it.
You
want
to
be
able
to
get
that
source
code
built
and
deploy
it
onto
the
cluster
in
a
reliable
and
consistent
manner.
A
They
also
want
a
ship
code
to
production,
faster,
I
think
this
is
pretty
obvious
right.
If
we
don't
do
it
fast,
someone
else
will
do
it.
So
it's
kind
of
a
part
of
our
digital
transformation
goal
as
well
to
be
able
to
deliver
more
features,
solve
customer
pain
points
faster
as
as
much
as
possible,
and
then
the
last
bit
is
observability.
So
we
have
this
this
principle,
where,
if
we
put
something
in
production
we
call
it
you
build,
we
build
it,
we
own
it.
A
Just
again.
These
are
kind
of
the
common
architecture
guiding
principles
that
we
go
by
reduce
time
to
value.
That's
the
number
one
you
know,
as
I
said
earlier,
we
need
to
ship
things
faster
to
production
everything
we
do,
we
build
it
as
api's.
It
needs
to
be
secured
by
design.
We
also
have
performance
and
scalability.
A
You
know
goals.
For
example,
we
look
at
the
number
of
customers
we
have.
We
have
hundred
million,
plus
customers
I.
Think
I
forget
the
exact
stats,
like
last
twenty
two
plus
quarters
we've
added
every
every,
like
1
million
every
quarter
right
so
massive
amount
of
scale.
So
everything
we
do
has
to
really
scale
at
that
level
and
then
all
the
scaling,
you
know
again,
I'm
not
gonna,
go
through
it
all,
but
it
just
gives
you
kind
of
a
high
level.
You
know
picture
of
some
of
our
guiding
principles,
and
so
what
happens
is
you
know?
A
We've
made
huge
platform
bets
if
you
look
at
who
here
was
at
Brandon
and
James
talked
on.
They
talked
about
the
platform
journey,
especially
on
the
on-premises
right,
so
you
you
can
see
the
the
amount
of
investment
we've
made
for
like
workloads
that
run
on
chemistries.
We
have
a
you
know,
few
examples.
We
have
a
past
platform
built
on
Cloud
Foundry
to
you
know
for
developers
to
deploy
their
applications
and
not
have
to
worry
about.
You
know
the
infrastructure
where
it
runs
and
things
like
that
and
we've
also
made
major.
A
You
know
investments
now
on
running.
So
if
we
pass
doesn't
work
for
you,
you
have
option
to
run
it
in
kubernetes
and
container
based
workloads.
So
again,
the
reason
why
I'm
saying
all
of
this
is
well,
especially
in
the
container
platform.
There's
a
lot
of
you
know,
gaps
in
terms
of
really
enabling
enterprise
developers
to
be
successful
in
deploying
their
workloads,
for
example,
auto
scaling
scaled
down
to
zero.
Why
would
we
want
to
you
know,
spend
if,
if
that
feature
or
service
is
not
being
used,
what
you
know
it's
taking
resources
on
the
cluster?
A
You
know
which
you
know
if,
if
you
scale
down
to
zero,
that
compute
could
be
useful
for
other
workloads
right.
So,
especially
when
you're
operating
in
a
shared
multi-tenant
environment.
It's
really
it's
really
key
right.
Cost
vena
from
a
cost
perspective,
so
point
here
is,
as
a
platform
service
provider,
there's
a
lot
of
investments
that
we
had
to
make
in
terms
of,
and
we've
been
doing
it
in
terms
of
tooling.
You
know
not
just
to
keep
running
the
platform
and
operating
on
it,
but
also
to
enable
developers
to
bring
their
workloads
right.
A
A
So
bit
of
a
history,
I
think
it
was
I.
Remember
if
I
remember
correctly
was
back
in
April
that
we
started
talking
about
Google
team
reached
out
to
us
and
said:
hey.
We
have
this
thing
called
a
native
would
be
awesome.
If
you
guys,
could
you
know
test
drive
it,
so
we
were
like
really
excited
right.
This
is
a
point
where
we
we
were
in
the
middle
of
our
platform
journey.
We
were
investing
in
tooling
and
whatnot,
so
it
made
really
a
lot
of
sense
for
us
to
actually,
you
know,
take
a
look
at
it.
A
Take
one
of
our
use
cases
actually
build
something
with
it
and
learn
from
it
and
that's
what
we
did
so
we
picked
this
use
case
called
store
locator,
so
I
want
to
spend
some
time
talking
about
what
this
is.
The
screenshots
you
see
here
are
from
our
mobile
app.
Our
customers
can
actually
go
and
see
what
stores
are
nearby
and
they
can
actually
go
to
the
store.
You
know
it
could
be
for
things
like
I
want
to
upgrade.
My
phone
or
I
have
I
have
to
go
and
maybe
pay
bill,
or
you
know
whatever.
A
That
is
right,
so
there's
so
that's
what
that's
why
they
use
the
service
for
currently,
this
service
is
actually
a
big
spring
boot
application
that
you
know
built
in
Java,
runs
in
a
container.
It's
always
running.
We
felt
like
this
is
a
use
case
that
really
fits
perfectly
with
this.
You
know
POC
that
we
want
it
to
do
back
in
a
you
know,
summer.
A
A
So
I'm
not
sure
I'm,
assuming
everyone's
familiar
with
K
native
here,
but
I
doubt
you
know,
I
just
included
this
slide
just
for
reference
point
of
view,
if
you're,
not
if
you're
not
familiar
with
it.
This
is
the
best
where
there's
a
lot
of
information
here
in
terms
of
community,
but
at
a
higher
level,
there's
really
three
things
that
we
get
with
K
native
the
building
serving
and
inventing
right.
These
are
three
kind
of
major
pieces
of
it.
A
Building
what
what
that
the
components
that
make
up
the
building?
What
that
does
is
it
allows
us
to
as
a
developer.
I
have
some
code
in
this
or
my
source
control
I
want
to
be
able
to
get
that
built
out
and
then
deploy
it
onto
the
cluster
right
there
that
that's
what
it
does
at
a
higher
level.
It
gives
us
those
low
level
primitives
that
helps
us,
give
the
code
out
onto
the
cluster
and
then
serving
you
know
things
like
traffic
management,
canari
deployments
being
able
to
do
blue
green
those
kinds
of
things.
A
Again,
you
don't
want
your
developers
to
worry
about
it,
so
serving
the
components
that
make
up
the
the
serving
component
of
it
allows
us
to
enable
those
kinds
of
scenarios,
and
then
the
eventing
piece
is
where
we're
able
to
build
like
really
decoupled
services
that
respond
to
certain
actions
yep
when
we
first
started
with
store
locator
back
in
summer.
This
was
kind
of
the
high-level
architecture,
as
you
can
see
here,
there's
really
two
kind
of
components
to
this.
One
is
the
indexing
piece
and
then
there's
also
a
query.
A
This
is
pretty
much
the
same
exact
architecture
with
the
current
service,
that's
actually
running
in
production,
the
spring
boot
application.
We
just
simply
took
that
and
then
just
convert
it
into
basically
serverless
KD
dove
services
right.
So
this
was
the
original
architecture
and
there
were,
as
you
can
see
from
here,
we
only
used
serving
components
of
it.
We
didn't
really,
you
know,
use
the
building
and
inventing
pieces,
so
it's
just
a
small
portion
of
cane
air
that
we
were
using.
A
Also
one
of
the
problem
here
was
when
we
were
starting
to
feed
Lord
like
a
file
with
lots
of
lots
of
store
data.
It
would
just
time
out,
especially
when
it
in
the
scenarios,
where
there's
nothing
running
and
then
it
you
know
everything
needs
to
come
up
right,
so
it
there
used
to
be
that
that
cold
startup
time
used
to
be.
You
know
a
problematic
scenario,
especially
the
first
time.
A
A
So
I
want
to
kind
of
walk
you
through
from
the
from
the
left
side
of
it,
which
is
basically
a
CLI
that
has
a
command
that
allows
us
to
like
load
store
data
into
our
data
set.
So
you
know
so
we
went
pretty
remember
previously.
We
were
just
directly
feeding
it
into
elastic
search
index.
So
now,
what
we're
doing
is
we're
actually
pushing
all
of
that
data
into
a
bigquery
table
kind
of
the
reason
for
doing
that
is
we
want
to
be
able
to
open
source
that
data
set.
A
So
and
the
other
thing
to
keep
in
mind
here
is
it's
actually
also
uploading
the
data
in
artists,
so
you
know
so
we
could
really
process
leg,
larger
files
and
even
in
from
an
indexing
standpoint
because
of
the
the
venting.
So
once
the
message
goes
into
our
topic,
then
it
gets
automatically
picked
up
by
the
eventing
infrastructure,
which
then
forwards
it
to
the
indexing
function
and
that's
the
the
guy
that's
responsible
for
adding
it
into
elastic
search
index,
so
we're
really
able
to
scaled.
A
So
as
the
as
we're
feeding
more
data
in
chunks,
the
the
K
native
serving
components
automatically
the
venting
system
will
pick
it
up
forward
it
to
our
service
and
then
serving
component.
You
know
piece
of
it
automatically
scales
the
pot
and
additional
replicas
run,
and
we
can
actually
really
scale
and
meet
the
demands
in
especially
processing
larger
files,
which
I'm
gonna
show
you
in
a
demo
and
then
the
the
other,
the
other
part,
which
is
the
query
which
there's
really
not
no
changes.
A
It's
just
the
same
exact
thing
that
we
did
in
the
in
back
in
the
PLC
and
then
the
third
thing
here
is
the
the
actual
building
pieces
of
it,
which
actually,
when
you
you
know
when
takes
the
code
from
the
repository
and
then
builds,
builds
the
container
image.
And
then
we
can
now
deploy
those
those
services,
so
I'm
going
to
switch
to
the
demo
and
what
I
want
to
do
is
I'm,
going
to
kind
of
walk.
Show
you
guys
right
from
the
bill
to
actually
the
query
and
indexing
pieces,
all
of
the
components.
A
So
so
we
have
this
repository
here
called
build
templates,
so
I'm
sure
you've
heard
by
now
that
the
KA,
the
building
components
had
this
notion
of
build
templates
which
allows
you
to
compose
a
set
of.
You
know,
steps
that
make
up
your
build,
build
process
right,
and
so,
if
I
look
at,
if
we
look
at
this,
for
example
again,
this
is
just
a
very
basic
template
that
has
two
steps
right.
One
is
it's
running.
A
A
A
Sonar
builder-
and
you
can
actually
see
it
here,
so
this
is
what
I'm
using
so
again.
The
key
point
here
is
not
big
the
build
we
have
a
now.
We
have
a
mechanism
here
that
we
can
actually
build
our
compose
our
own
steps
and
actually
contributed
to
the
community
and
community
can
also
take
benefit
of
it.
If
you
really
think
about
how
we
do
this
today
in
the
if
you're
using
Jenkins,
what
we
do
today
is
we
have
shared
libraries
right
whenever
there's
common
steps
that
everybody
is
gonna
need.
A
We
create
a
shared
library,
but
it's
very
difficult
to
test,
and
it's
it's
really
painful-
to
kind
of
meet,
maintain
from
a
long-term
perspective
right.
So
again,
this
is
so.
This
is
I'm
using
the
same
builder
that
I
contributed
back
to
the
community
from
here.
So
so
that's
the
first
step,
so
I
run
the
static
code,
analysis
and
then
I'm
just
simply
doing
a
building
and
push
so
it
basically
builds
the
container
image
and
then
pushes
into
into
a
container
registry.
So
let
me
quickly
show
you
how
that
process
works
like
so
before.
A
I
do
that
I
have
to
do
if
one
small
thing
which
is
update
so
go
to
the
query
and
I'm
gonna
have
to
because
sonar
users
I'm
using
a
token
I'm
gonna,
actually,
obviously,
I
didn't
want
to
check
in
the
token
into
the.
So
you
know
github.
So
that's
why
I
kind
of
left
it
there
blank
so
I
have
the
token
saved
down
here
so
I'm
gonna
copy
from
here
and
I'm
gonna
paste
it
in
here.
A
A
A
A
Should
see
some
analysis
reports
here
right,
it's
still
I
think
the
container
build
is
still
going
on
so
build
and
push
so
it
takes
a
little
bit
of
time,
but
pretty
soon
we
should
see
an
image
up
here
again.
If
we
want
to
see
the
logs,
we
can
just
go.
I'm
gonna
go
and
grab
that
that's
that
build
container
and.
A
And
know
last
night,
when
I
was
running
it
was
it
was
actually
she
would
show
like
an
error
here
as
well.
Luckily,
it's
not
showing
that
now,
it's
obviously
you
know,
there's
there's
options
for
build
this
piece
to
in
it's
fairly
new
there's
still,
as
you
can
see
in
terms
of
troubleshooting
I'm
still
have
to
you
know,
pulling
logs
from
different
containers,
and
so
it's
not
quite
in
terms
of
like
handing
over
to
a
development
group.
A
It's
it's
really
not
quite
there's,
there's
still
a
lot
of
tooling
that
needs
to
happen
higher
level
abstraction,
but
as
a
platform
provider.
It's
kind
of
interesting
right,
because
we,
as
I
mentioned,
if
you're
running
you
know
on
a
card,
you
know
Jenkins
or
whatever
solutions
using
there's
a
lot
of
pain
points
in
terms
of
you
know,
sharing
and,
and
things
like
that.
So
this
the
model
here
is
so
simple
that
it
enables
folks
to
contribute.
You
know
their
own
specific
builders
and
and
and
and
share
it
with
a
greater
community.
A
A
A
So
that
actually
will
now
go
so
if
I,
if
we
just
look
at
the
the
query
that
llamo
file-
basically
it
has
two
things:
one
is
the
route
and
then
the
configuration
so
I'm
actually
sending
100%
of
traffic.
To
my
existing
version,
that's
running
I
mean
you
can
do
things
like
if
you've
watched
all
the
different
K
native
demos,
you
can
really
have
multiple
divisions
and
actually
distribute
traffic
across
those
revisions,
but
for
now
I'm
just
going
to
go
with
this.
So
this
time
it
takes
a
little
while
just
make
sure
it's
running.
A
A
So,
in
terms
of
next
steps,
what
we,
what
we're
hoping
to
do
is
we're
gonna.
We
want
to
open
source
the
data
set.
We
want
to
actually
make
the
service
into
a
multi-tenant
application
and
t-mobile
being
being
the
first
10
and
every
every
retail
customer
has
this
scenario
right.
The
store
finder
is
something
that's
pretty
common.
We
want
to
build
web
mobile
and
auto
experiences
on
top
of
it,
so
you
can
interact
with
the
with
the
service.
You
know
which,
using
any
of
those
mechanisms.
A
We
also
want
to
leverage
the
build
pipeline
which,
right
now
the
build
just
gets
from
source
to
container
image.
So
we
want
to
be
able
to
leverage
the
entire
pipeline,
so
we
can
actually
deploy
all
the
way
back
down
into
the
cluster.
We
also
want
to
take
the
integrate
with
the
digital
assistance,
so,
if
you're
driving,
you
can
actually
do
a
voice
based
interaction
with
the
service.
Also,
the
last
thing
here
is
integrating
with
services
like
lyft
and
uber.
For
so,
if
you
wanted,
you
know,
let's
say,
get
directions
or
drive
straight.
A
You
know
to
the
store
you
can
actually
automatically
book
the
you
know
through
lyft
or
uber.
Just
in
summary,
a
couple
of
things
I
want
to
call
out
is
I.
Think
we're
really
excited
to
see
the
not
just
the
community
you
know
developing,
but
also
the
partner
is
actually
building
integrations
on
top
of
the
platform,
so
that
gives
us
a
choice
in
terms
of
if
we
want
to
buy.
A
Third,
you
know
part
third
party
versus
build
our
own
and
as
a
platform
service
provider,
we
get
a
lot
of
the
low
level
primitives
that
we
can
use
to
actually
build
a
higher
level
abstraction
tolling.
So
we
have
a
choice
in
terms
of
build
were
seized
by
and
then
we
think
that
this
is
going
to
be
the
future
in
terms
of
how
we
build
services.
You
know
cloud
native
services
and
it's
been
really
fun
to
work
on
this
project
with
the
Google
team.
A
It's
been,
you
know
it's
amazing,
to
see
the
community
been
very
responsive
in
terms
of
when
we
run
into
problems
and
especially
when
we
started
way
back,
you
know
all
we
had
was
basically
code
that
was
in
documentation.
Wasn't
there
and-
and
we
didn't
really
know
how
things
were-
there
was
a
lot
of
collaboration
with
the
teams
and
and
were
able
to
really
learn
more
about
the
project
and
and
build.
You
know
a
real
use
case.
A
A
A
So
this
has
a
command
here.
Load
load
command
that
what
happens
here
is
the
scroll
all
the
way
up
here.
So
this
is
the
this
is
what
gets
called
when
I
do
load
data
and
we
just
make
sure
the
file
is
valid
and
all
of
the
other
parameters
required
parameters
like
bigquery
table
name
are
all
here
and
then
we
parse
some
data
from
the
config
file,
and
it's
actually
here
it's
actually
creating
a
new
bigquery
tape,
client
and
then
it
will
go
and
create
the
data
set
here,
create
the
table.
A
A
And
then
we
pushes
it
we'll
chunk
it
down
here
in
batches
and
then
and
then
insert
row,
call
the
insert
row
actually
which
inserts
the
rows
into
the
table
and
then
call
the
publish
message
that
actually
pushes
a
message
into
the
queue
and
I
think
I'm
about
running
out
of
time
and
the
other
main
piece
out
real
make
this
really
quick.
The
other
key
piece
here
is:
we
have.
A
This
is
we're
using
the
GCP
pub/sub
source
as
a
way
to
kind
of
say
what
happens
here.
Is
here
we're
specifying
here's,
my
my
key
and
then
credentials
to
talk
to
GCP
and
then
this
the
Google
project,
that's
the
topic,
and
then
this
is
the
the
serve.
Is
that
whenever
there's
a
message
it
forwards
to
that
service,
which
is
the
indexer
service
that
we're
looking
at-
and
this
has
an
endpoint
here-
that
actually
speaks
cloud
event.
A
So
here
you
can
see
I'm
taking
the
the
payload
and
then
converting
it
back
into
a
cloud
events
and
then
grabbing
the
the
pub.
You
know
basically
converting
the
into
a
pub
sub
message
here
and
and
then
from
there
I
grab
the
data,
which
is
where
my
actual
store
records
are
and
then
that
go.
You
know
that
gets
then
added
to
the
elastic
search
index.
Here's
here's
instantiates
the
proxy
and
then
adds
it
to
the
index.
So
that's
how
that
whole
indexing
piece
is
working.
A
Unfortunately,
I
ran
out
of
time,
I'm
not
going
to
be
able
to
actually
show
it
working,
but
all
of
the
code
is
actually
up
here
in
the
github,
and
you
know
if
you
you
can.
If
you
were
looking
for
like
real
mole
samples
and
how
to
use
you
can
go,
go
to
this
repository
and
and
and
take
a
look
at,
and
if
you
have
questions
there's
my
contact
reach
out
to
me.
If
there's
any
questions
on
the
pub
sub
pieces,
thanks
guys.