►
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
Serverless Operations: From Dev to Production - Erwin van Eyk, Platform9
FaaS functions on Kubernetes are increasingly popular. We often talk about the developer productivity advantages, such as the time to create a useful application from scratch without learning a lot about Kubernetes. In this talk we will focus on the operational aspects of serverless applications on Kubernetes. What does it take to use serverless functions in Production, with safety, and at scale? This talk covers 6 specific approaches, patterns and best practices that you can use with any FaaS/Serverless framework. These practices are geared towards improving quality, reducing risk, optimizing costs, and generally moving you closer towards production-readiness with serverless systems.
https://sched.co/MPej
A
A
Basically,
how
can
you
use
them
personally
and
benefit
from
them?
So
basically,
this
these
lessons,
I
became
I'm
going
to
share
with
you
are
basically
things:
we've
been
learning
top
by
talking
to
our
costs,
our
users
from
fishing
and
fishing,
which
is
basically
a
open
source,
fast
service
platform
on
communities
for
which
basically
I
work
at
last
nine,
okay,
so
big
room,
so
I'm,
not
sure
I
am
sure
some
of
you
have
already
got
an
introduction
to
surplice
I.
A
Just
don't
have
a
quick
recap,
but
trust
me
it'll
be
quick,
so
why
service
I
think
that's
based
on
three
characteristics:
one
is
the
operational
model,
and
so
basically
there
it's
about
the
Q
as
a
user,
the
first
so
much
of
your
operate
so
as
much
as
possible,
your
operational
logic
to
the
cloud
provider.
So
basically
only
an
interview
should
only
need
to
focus
on
your
actual
business
logic,
actual
actual
code
that
you
care
about.
A
A
lot
of
things
should
be
referred
to
as
much
possible
through
a
cloud
provider
and
then
in
return,
you
get
a
lot
of
things
for
free
back.
So
one
of
this
is
the
that
the
cloud
provider
does
the
out
scaling
for
you
and
all
the
things
I
ski
cat
you
get
for
free
is
basically
monitoring
health
checking
out
that
sort,
the
other
next,
the
operational
model.
A
You
have
to
cost
model,
and
that's
maybe
the
one
thing
is
more
more
famous
for
service
than
the
outer
scaling
part
I
was
basically
only
pay
for
extra
research
that
you
use
and
you
don't
pay
basically
for
reserving
machine
instances
that
you
don't
fully
utilize
in
the
next
round.
You
also
don't
pay
any
up
front
cost
or
barely
cost
that
are
not
directly
correlated
to
your
usage.
A
A
You
really
try
to
focus
you
you're
working
on
as
close
as
possible
to
the
business
logic,
so
we
also
knew
using
high-level
abstractions
such
as
functions
or
queries,
and
next
that
also
the
cloud
productized
tries
to
provide
you
with
as
much
services
as
possible.
So
if
you
don't
have
to
do
grunt
work
of
integrating
with
a
storage
service
or
with
a
message,
queue
and
finally,
service
is
really
about
being
also
being
language.
A
As
a
developer,
you
express
your
business
logic
in
functions
and
these
functions
you
submit
to
the
fast
that
form
which
is
basically
up
which
operators
by
an
operator
and
this
operator
can
be
public.
It
can
be
a
double
yes,
it
can
be
Google.
It
can
also
be
an
internal
DevOps
team
which
basically
manages
a
self
deployed
as
self
deploy.
It's
a
fast
platform
and
the
whole
goal
is
fast.
That's
basically
turn
your
functions
into
function,
instances
which
are
basically
workers
that
process
your
events
for
these
functions
and
execute
the
function
for
it
and
this.
A
Basically,
this
allows
you
to
to
serve
a
certain
number
of
users
which
base
heat
form.
The
workload
whether
they
are
actual
users
or
maybe
just
downstream
services
and
I
might
be
wondering
this
seems
very
simple.
While
entire
talk
about
service
operations,
the
problem
here
is
that
you
don't
when
you're
using
servlets,
you
don't
just
use
a
single
function
anyway,
when
you
start
investing
into
service
our
structures,
you,
the
the
the
small
bases,
the
constrain
model
of
a
function.
A
It's
basically
forced
you
sort
of
to
keep
your
phone's
very
small,
and
also
the
cost
of
adding
a
new
function
is
very
cheap.
So,
as
you
can
see
between
the
recent
survey,
an
idea
worse,
the
users
we
have
more
health
usually
have
more
than
function.
Without
some
some
live.
Hundreds
and
others
have
thousands
of
functions.
A
You
can
imagine
that
once
you
have
this
number
of
functions,
tens,
hundreds
or
going
all
being
deployed
on
concurrent
of
being
upgraded
being
defecated,
but
suddenly
it
becomes
much
more
complex
to
actually
manage
this
overall
picture
can
get
a
good
insight
in
this
in
what's
happening
in
your
system.
For
this
we
need
actual
structure,
operational
processes
and
luckily,
there's,
of
course,
a
lot
of
existing
work
on
this.
A
So
now
you
might
wonder
like
how
does
this
change
in
surplice
completing
this,
this
basically
step
of
loop
lucky?
Luckily,
it
doesn't.
Basically
the
core
principles
of
this
data
loop
should
remain
the
same
for
service
up
your
service
computing.
You
going
to
have
this
serve
your
surplice
applications,
fit
into
your
workflow
into
your
your
processes,
instead
of
adapting
oil
process
to
this
one
single
Oh
catchphrase.
A
So,
but
of
course,
you
can
imagine
that
even
within
these
these
stages,
there
are
still
a
lot
of
differences,
there's
a
lot
of
practices
that
are
a
bit
different
in
serve
list
and
also
serve
practice
that
are
specific
to
service.
So,
today,
I'm
going
to
drain
the
rest
of
the
talk,
and
with
this
guy
I'm
gonna
share
a
few
whiskey
for
each
of
these
stages.
Basically,
what
what's
different
in
service
of
what
you
should
watch
for,
and
basically
what
are
good
practices
in
general
when
using
a
service.
A
So
first
up
the
development
loops
always
give
real.
Now,
who
is
he
changing
our
feature,
implementing
a
feature
and
killed
the
key
thing
of
this
develop,
and
basically
this
holds
for
any
application,
not
just
the
service.
One
is
that
you
should
keep
it
as
small
and
as
fast
as
possible.
Basically
to
keep
is
this
feedback
to
the
user
as
far
almost
instant
and
in
for
service
is
also
the
same,
but
also
there's
also
a
bit
more
a
bit
more
tricky
part
to
the
to
service?
A
A
So
now,
instead
of
actually
having
this
by
we're
waiting
for
your
count
equal
to
a
poly,
now
you're
waiting
for
your
code
to
be
uploaded
for
to
be
deployed
and
to
be
exposed
to
your
V
PC,
for
example-
and
it's
not
of
course
sorry
not
not
to
say
that
it's
not
the
good
place
to
start
these
online
editors
that
basically
all
fast
riders
show
have
sorry.
We
are
a
good
great
point
to
start
exploring
service
to
basically
tight
bits,
maybe
for
a
small
hackathon
to
create
quickly
set
up
some
features.
A
But
there
are
some
limitations
to
these
online
editors
and
basically
they're
there
couple.
So
one
is
team
that
are
limited,
that
I
have
limited
functionality
some
time
most
of
times
the
API
of
your
fast
platform
has
more
functionality
than
is
presented
in
the
editor
and
accidentally,
the
they
also
just
missing
there.
They're
missing
the
typical
IDE
functionality.
A
Id
functionality
like
what
your
favorite
ID
has
advanced
typing,
your
your
self
defined,
macros
and
so
forth,
and,
finally,
the
also
these
editors
also
missing
a
bit
of
a
good
good
version
control,
because
they're
they're
not
present,
you
cannot
really
get
them
from
there
into
your
own
version
control
system,
so
you're
basically
dependent
on
any
OBS
to
infinite
this.
For
you
and
I,
do
I
do
create
some,
for
example,
I
could
do
create
a
snapshot
for
every
time,
your
function
that
gets
deployed,
but
the
still
risky.
A
And,
of
course,
the
answer
is
very
simple:
just
developed
locally,
and
luckily
these
functions
that
we
defined
servers
are
not
special.
They
don't
require
some
special
API.
They
can
just
be
developed
in
your
own
IDE
and
are
some
project
actually
help?
You
further
develop
your
surface
applications
so,
for
example,
a
give
us
some
surface
application
model
which
basically
allows
you
to
also
specify
the
code.
The
function
configuration
in
code
for
will
receive
like
that.
You
have
the
function
and
the
configuration
in
the
same
environment.
A
A
So
that's
basically
started
basically
develop
your
analysis,
developing
locally
myself,
we're
testing
our
functions
and
we
still
always
have
to
upload
them,
twenty
twenty
others
to
Google
clouds,
and
that
takes
a
lot
of
time.
So
there
are
a
couple
options
here
to
actually
also
speed
this.
This
part
of
the
local
developer
experience
up.
One
s
whiskey
was
using
a
fast
emulator,
so
much
every
managed
fast
platform
has
one
or
multiple
emulators
which
basically
well
they
implement.
The
same.
Api
is
a
reverse,
but
are
far
far
simpler,
are
open.
Source
advice.
A
Key
are
good,
a
good
way
to
actually
test
your
functions
of
line,
but,
of
course,
if
you're,
if
you
have
your
functions,
you
if
you
have,
if
your
functions,
that
they
typically
like
glue
codes,
are
they
they're
interacting
with
services
so
you're
still?
If
you
want
to
fully
test
those,
you
still
have
to
sort
of
interact
with
the
cloud.
Now
you
can,
you
can
go
even
further
and
say
basically,
I
want
to
emulate
everything
and
there's
a
nice
project
called
local
stack
that
actually
tries
to
do
this.
Basically
they've
basically
emulated
at
least
a
claim.
A
I
haven't
really
checked
it
that
I
Emily
basic
entire
ap,
the
entire
API
of
a
Tobias
leather,
but
problem
versus
these
systems
is
and
if
you've
been
around
in
cloud
computing
for
longer
than
you've
recognized.
At
least
these
attempts
have
been
made
of
multiple
tiers.
Also
is
that
basically
they
this
these
projects
are
quite
difficult
to
do,
because
you
have
to
constantly
this
this
local
sagas
consti
has
to
keep
in
sync
with
AWS
and
basically
constantly
keep
a
sync
radio,
where's
Davis,
it's
constantly
evolving,
of
course.
A
So
it's
difficult
to
keep
these
these
two
in
sync
and
similarly,
you
could
try
to
do
a
diverse
em
local,
which
also
is
an
emulator
for
files,
but
also
for
some
of
these
services
that
are
related
to
this,
as
though
it's
far
smaller
than
the
local
stack
scope.
But
it's,
but
it's
at
least
it's
it's
it's
developed
by
a
aware.
So
that's
the
the
chance
that
I
are
keeping
sync
will
be
bigger
but
still
use
the
users.
A
Rf
also
has
to
be
in
sync,
so
you
have
to
comes
people
surely
here
and
using
the
latest
version
of
Adobe
Sam
local,
so
it's
tricky,
but
you
can
try
to
explore
if,
if
you
think
it's
useful,
so
the
third
option
is
using
an
open
source
fast
platform.
So
that
restricts
you
bit
in
what
you
can
choose,
but
the
advantage
of
these
fast
platforms
of
the
job
you're
faster
in
the
name.
A
A
So
now,
basically
we're
developing
locally
with
testing,
maybe
at
least
a
unit
test
locally.
We
can
go
even
further,
so
this
is
something
where
we
can
take
a
look
at
the
the
front-end
community,
they're,
basically
like
when
you're
working
on
your
website.
If
you
have
many
many
tools
which
basically,
what
your
file
system
and
once
you
make
changes
to
your
website,
your
source
code,
you
immediately
get
basically
music's
real,
compiled
and
deployed
to
get
to
a
local
website,
and
your
project
gets
refreshed.
A
A
So
we
can
do
this,
basically
using
a
very
simple
do-it-yourself
type
of
thing
where
you
just
watch
your
file
system
deploy
in
you
for
your
functions
when
it
changes,
but
also
there
are
more
and
more
service
platform
to
actually
try
to
also
move
towards
this
kind
of
developer
experience
so
to
our
bit
related
natalie
phi
insight,
which
are
both
basically
service
platforms
that
focus
really
on
making
service
web
applications.
So
they
really
try
to
follow
this
front-end
workflow
and
also
using
us
this
life,
this
life
reloading
in
fashion.
A
We
have
also
a
feature
for
this,
but
here
which
basically
builds
and
deploys
your
functions
in
communities
as
you
were
working
on
them.
Ok,
so
now
we
have
place
skin.
Ok,
ok,
yes!
So
now
we
have
the
with
basically
our
change,
so
we're
not
really
trying
we're
trying
to
basically
put
it
into
the
operation
loop.
So
we
refers
to
to
build
this.
A
Ok,
ok,
so
the
basically
built
by
the
build
stage
is
basically
about
turning
your
function,
sources
into
actual
deployables,
and
this
event
depends
a
bit
on
how
fast
lettering
uses
some
use
a
darker
darker
images,
some
use
archives,
but
the
core
principle
remains
the
same.
So
does
the
defendant,
so
also
this
built
pipeline
except
implementation
depends
really
on
the
language
you
use
so,
for
example,
in
Google
Cloud
functions.
A
If
you
are
using
no
chess
and
you
place
a
packaged
adjacent
file
with
your
dependency
head
in
the
bill
type
line
of
Google,
they
will
try
to
resolve
your
dependencies,
but
when
you're
deploying
your
function,
yeah,
so
that's
cool
I,
also,
for
example,
ok
native
as
this
as
this
project
called
built,
which
is
also
is
the
goal
of
this-
is
also
to
provide
a
very
high
level
diesel
for
pressure
for
creating
your
build
pipelines,
yeah
and
some
other
cases.
Your
in
some
other
cases,
the
serve
platforms.
A
So
moving
on
to
be
built,
this
deployable
function.
So
we
now
again
we
we
enter
this.
This
testing
loop,
which
is
this
this
time,
far
larger
than
the
the
test
that
we
did
in
the
development
environment,
because
certainly
we
don't
have
to
care
whether
it's
going
for
around
whether
it's
going
fast.
So
this
yeah
you've
probably
noticed
this
experiment
assessing
parents
in
service.
Some
argue
that
some
argument
is
the
same.
Some
argue
that
it
should
be
more
like
an
Aztek,
their
pyramid
thickness.
A
A
A
So
basically,
you
have
one
free
integration
tests
for
each
of
the
dependencies
or
the
the
survey
which
are
integrated
and
the
message
that
I
scale.
So
this
allows
you
to
keep
your
tests
simple
and
also
allows
you
to
root
cause
which
service
has
change,
has
become
incompatible
with
your
function
and
some
other
some
smaller
tips
reach
out.
So
using
this
try
to
avoid
hard
scoring
any
sir
in
any
service.
Lay
the
details
really
focus
with
separate
your
testing
from
your
production
environment
so
use
different.
A
Okay,
so
we
basically
thank
Becky
built
our
function,
we've
tested
it
so
now
it's
ready.
We
can
actually
start
focusing
on
the
release
of
getting
it
into
the
codebase
and
releasing
a
new
version
of
our
function
and
for
this
yeah
I've
seen
this
introduction
for
forget
up
of
times
even
at
this
conference.
A
So
I'm
disconnected
it's
very
simple,
but
the
idea
of
qdubs
is
basically
that
you
put
everything
with
everything
ready
to
your
application,
ready
to
the
deployment
in
the
in
the
same
git
repo.
So
basically
it
becomes
a
single
source
of
truth
in
your
your
system
or
in
your
architecture
and
from
from
the
sketch
we
probe
your
CD,
tooling,
watches
for
for
changes,
watch
for
new
commits
and
basically
gets
triggered
to
redeploy.
A
So
the
question,
of
course,
is
because
you
have
this.
This
deployment
configuration
the
question.
Of
course.
How
do
you
actually
represent
this
I?
We
actually
store
this
in
your
gaze
repo,
and
so
one
option
is
to
do
imperatively
so
basically
having
small
batch
script,
which
basically
deploys
your
your
function.
A
So
the
alternative
is
which,
because
it's
because
it's
coupon
everyone
knows
right
now-
is
to
use
declarative
configuration
so
similar
to
community
specs.
So
here's
an
example
of
basically
the
same
operation
button
in
declarative,
whisk
in
declarative
way,
so
basically
I
think
the
key.
The
key
advantage
of
this
approach,
basically
hue
lose
the
first
issue.
I
had
mentioned
earlier,
so
that
the
operations
so
the
debases
you
don't
have
to
worry.
A
Every
system
has
a
declarative,
at
least
a
declarative
way
to
specify
your
configuration,
so
it
was
some
surf
a
framework
and
basically
every
open
source
fast
platform,
that's
on
top
of
Cuban
at
ease
because
they
want
to
integrate
the
communities,
you're,
sort
of
forced
to
use
declarative
configuration,
which
is
good
thing
move
down.
So
we
have
this.
We
basically
have
merged
our
changes
into
the
actual
code
base
and
we
are
now
by
ski
bred
to
deploy
the
rebound
base,
cube
ready
to
deploy
the
application
or
the
function.
A
For
this
we
can
actually,
we
can
actually
take
a
bit
of
a
detour
and
we
do
committed
unto
how
a
fastest
from
deploy
C
functions.
I
know
I
said
you
need
to
know
and
if
any
operational
logic
of
the
fastest
form,
but
it's
actually
kind
of
useful
to
know
so
bear
with
me
so
in
the
fast
platform
there's
a
router
component,
which
basically
is
the
problem
which
decides
where
to
send
your
your
friend
to
so.
A
If
there's
a
function
instance,
it's
all
sent
there,
otherwise
it
so
basically
issued
to
the
lawyer
expressed
for
a
certain
function.
Instance.
This
deploy
basically
knows.
Besides
how
a
function
should
be
deployed,
what
kind
of
resources
should
should
use
and
it
all
flows,
actual
scheduling
and
deployment
of
these
dysfunctions,
doing
which
manager
and
of
course
this
is
communities
and
communities
basically
takes
the
function
from
the
function,
store
and
deploys
it
as
a
function
instance.
A
So
now
we
have
this
function
instance
and
we
can
merely
rather
basically
cannon
browse
this
event
to
the
function
instance
for
processing
and
this
whole
display
ski
is
long.
Psycho
or
long
process
is
basically
what
we
call
a
cold
start.
It's
basically
in
the
worst
case
possible
path
like
your
excuse,
you
can
take
to
be
executed
executed.
So,
in
contrast,
when
we
have
now
a
second
event
coming
in
and
we
have-
we
still
have
this
function
instance
around.
So
we
can
immediately
for
these
events
to
the
function
instance
and
this
basic.
A
Okay,
this
is
called.
Oh,
it's
not
doesn't
really
have
a
name,
it's
basically
it's
of
warm
execution.
The
risk
is
the
opposite
of
a
cold
start,
and
basically,
with
this
knowledge,
we
can
actually
do
some.
Some
pretty
interesting
things
to
optimize
your
performance,
your
functions
and
that's
basically
to
do
some
caching
inside
your
functions
because
functions
are
stateless.
They
can't
hold
any
persistent
state,
but
it
can
hold
some
non
persistent
state
like
caching.
A
Okay,
so
imagine
that
you
have
this
ESP
go
back
to
the
previous
slide,
where
we
have
this
function,
instance
being
deployed,
we
can
when
we
deploy
things
we
deploy
the
function.
We
of
course
load
the
extra
modules
in
your
in
this
function
instance.
So
what
you
can
do,
especially
you
can
put
some
codes
outside
of
your
function,
handlers
about
outside
of
the
function
itself
into
the
package
level
and
which
capacity
gets
executed
when
the
function
gets
deployed.
A
So
when
you
deploy
your
functions
use
even
though
you
have
tested
them,
you
can't
really
guarantee
that
you
actually
have
a
fool
like
you
have.
If
you
could
kind
of
have
full
confidence
that
you
actually
have
a
working
function,
so
you
still
need
to
monitor
it
when
it's
really
deploy
it,
that
it
actually
works
and
it
works
as
it
should,
and
you
can
do
it
manually.
A
But
when
you
have
these
tens
or
hundreds
of
functions
you
it
quickly
becomes
far
too
tedious
part
in
difficult
to
actually
keep
track
of
which
functions
you
should
watch
which
functions
are
already
longer
running,
which
are
more
stable.
So
that's
why
you
start
to
ultimate.
Is
these
deployments
are
using
connect
canary
canary
deployments
and
I
did
ask
if
current
of
poems
is
very
simple?
What
you
do
is
basically
you
deploy.
A
This
is
an
example
of
fission
of
the
fission
Clara
deployments,
an
innovation
and
see
an
example
of
a
succeeded
canary
canary
deployment,
where
in
Green
Bay
skeeters
one,
the
new
version
is
getting
more
and
more
traffic
as
the
red
one
decreases
in
traffic
and
Kenner
departments
are
getting
more
and
more
adopted
by
service
platforms,
so
at
least
I
know
it
was
Linda
supports,
is
by
using
by
combining
it
with
a
US
code,
deploy
and
with
in
service
meshes.
Basically
carry
permits
are
almost
one
of
the
standard
features.
A
So
that
brings
us
to
the
last
part
the
loop
which,
basically,
no
you
have
to
applaud
your
functions
now.
It
knows
the
last
time
to
actually
take
the
dong,
long
road
and
operate
and
monitor
them,
and
unfortunately,
yes,
you
still
have
to
monitor
your
service
applications,
because
the
cloud
party
cannot
do
anything
for
you.
A
The
cloud
private
does
manage
a
lot
of
the
mention.
A
lot
of
the
system
level
measurement
of
the
system,
level
metrics,
but
at
a
higher
level,
the
clock
burden
can
never
know
whether
your
functions
operate
actually
actually
intended
and
whether
they
meet
internal,
isolate.
Of
course,
the
service.
The
service
platforms
do
help
with
this,
so
they
do
provide
material,
metric
monitoring,
log,
aggregation,
storage
and
distributing,
but-
and
this
this
a
few
from
another
lot
of
development
issues.
Development
trouble
to
actually
set
up
this
and
set
of
this
monitoring
infrastructure
yourself.
A
But
there
are
some
pitfalls
also,
especially
when
you're
using
managed
fast
platforms,
because
this
monitoring
is
not
free,
you
still
get
paid.
It
gets
charged
for,
for
example,
how
many
locks
you're
sending
to
the
to
the
lock
service
and
also
there's
a
bit
of
a
I
personally
think
it's
a
bit
of
a
vendor
lock-in
in
this
this
part
of
service
because
you're
you
don't.
A
We
have
a
choice
which
monitoring
stack
you're
using
so
when
you
using
it
with
lambda
you
using
cloud
watch
when
using
go
cloud,
functions,
you're
using
stack
driver
and,
if
you,
even,
if
you're,
using
an
open
source
faster
from
generally
days,
they
still
assume
a
certain
monitoring
stack
and
it's
hard
to
actually
use
a
different
one,
and
so
the
basically
the
remainder
of
this.
This
talk
I
want
to
spend
a
bit
on
things
that
you
can
likely
to
find
when
you're,
when
you
start
operating
and
monitoring
your
function
for
a
longer
time.
A
So
the
first
one
is
basically
that
the
memory
allocation
actually
impacts,
also
the
CPU
and
the
I/o
of
your
function.
So
generally,
when
using
a
device
Landa
your
you
can
only
set
the
the
resource
allocation,
the
resource
allocation
for
your
function,
so
that
might
sound
with
where
them
to
to
sudden
get
more
memory
to
a
function.
It's
in
principle,
CPU
intensive
such
as
the
fibonacci
example
here,
but
because
they,
basically
because
under
the
hood,
the
the
fast
provider
does
link
the
memory
allocation
to
the
CPU
shares
an
IO
share,
almost
linearly.
A
You
see
that,
basically,
even
in
these
cpu
intensive
functions,
you
kind
of
performance
books,
another
performance
issue
or
former
Foreman's
opportunity
is
basically
that
you
can
opt
for
to
not
scale
down
to
zero
and
it
goes
a
bit
against
the
surface
principles
of
not
not
paying
for
things
you
don't
use
but
ideas.
Basically,
if
you,
if
you're
willing
to
pay
more
for
your
functions,
you
might
consider
just
leaving
them
running
for
a
lot
for,
for
basically
always-
and
this
is
not
really
well
supported
yet
in
fast
platform.
So,
for
example,
I.
A
So
the
final
form
is
issue
that
I
found
Percy
very
interesting,
because
I
actually
went
into
it
myself.
It's
basically,
the
language
actually
does
matter,
because
I
used
to
figure
very
of
course
I
go,
might
be
a
bit
faster
than
Python,
but
for
a
single,
simple
function
with
with
just
a
single
single
thread.
It
shouldn't
really
matter
that
much
but
in
practice,
actually
it
doesn't
matter,
and
the
reason
for
this
is
not
because
the
language
is
because
of
the
language,
if
it's
more
about
the
language
implementation,
so
I
actually
rented
into
it.
A
So
that
basically
concludes
the
products,
basically
the
lifecycle
and
also
it
brings
an
end
to
this
talk.
I
try
to
summarize
VD.
Basically,
lessons
learned
as
I
present
this
presentation,
but
I
think
the
main
takeaway
of
this
presentation
is
first
one
is
that
basically,
servlet
does
still
have
this
still
have
ops,
and
especially
when
you're
running.
Basically,
when
you're
running
service
at
scale
Yuri,
you
really
need
structured,
operational
processes,
and
for
this
the
DevOps
lifecycle
is
still
very
relevant
in
service
and
that's
a
good
thing.