►
From YouTube: GitLab and Google webcast - Running Containerized Applications on Modern Serverless Platforms
Description
In this webcast, we'll walk through some of the benefits and challenges of using cloud-vendor-specific serverless technologies. With Kubernetes as an infrastructure abstraction organizations can take advantage of hybrid (cloud and on-premises) as well as multi-cloud compute. We'll show you how to containerize a traditional application and deploy it to a variety of environments including Cloud Run as well as any Kubernetes cluster using GitLab Serverless.
Get up to $500 in free credit for Google Cloud Platform: https://bit.ly/2FDn6bw
Subscribe to hear about upcoming webcasts: https://bit.ly/2LtnePY
Read more about our product vision: http://bit.ly/2IyXDOX
Learn about FOSS & GitLab: http://bit.ly/2KegFjx
Get in touch with Sales: http://bit.ly/2IygR7z
A
Well,
good
afternoon,
good
morning
or
good
evening,
depending
upon
where
you
are
in
the
world
and
welcome
to
today's
DevOps
comm
webinar,
I'm,
Charlene,
O'hanlon
moderator
for
today's
event
and
I
welcome
you.
As
always,
we
have
a
great
webinar
on
tap
today.
It's
lots
of
great
information,
but
before
we
get
started,
we
do
have
a
few
housekeeping
items.
We
need
to
go
over.
First
of
all,
today's
event
is
being
recorded.
A
So
if
you
miss
any
or
all
of
the
event,
you
will
be
able
to
access
it
on
demand
later
on,
following
today's
webinar
we'll
be
sending
out
an
email
that
contains
a
link
to
access
the
webinar
on
demand
and
we
are
taking
questions
from
the
audience.
So
if,
at
any
time
today
during
today's
presentation
you
have
a
question
for
either
one
of
our
panelists,
please
don't
wait,
don't
hesitate,
just
use
your
GoToWebinar
control
panel
and
submit
your
question
and
we'll
take
a
few
minutes
near
the
end
of
today's
presentation
and
go
through
those
audience
questions.
A
And
finally,
at
the
end
of
today's
webinar,
we
are
going
to
be
doing
a
drawing
for
350
dollar
Amazon
gift
cards
so
stick
around.
Hopefully,
your
name
will
be
one
of
the
three
chosen:
okay
with
that
we'll
go
ahead
and
kick
off
today's
webinar,
which
is
running
containerized
applications
on
modern
service
platforms.
Our
speakers
today
are
William
chia,
who
is
in
product
marketing
at
GUID,
lab
and
I
met.
Alt
Balkin,
who
is
a
developer
advocate
at
Google,
welcome.
Gentlemen.
Thank
you
so
much
for
joining
me
today.
Whoa.
B
B
The
first
question
we
would
like
to
know
about
is
how
often
in
your
organization
you
deploy
to
production,
and
so
you
know
every
six
months
or
longer,
maybe
one
one
production
deployment
every
six
months
are
longer
once
per
month,
or
maybe
once
every
few
months
once
per
week
or
a
few
times
per
month,
once
per
day
or
multiple
times
per
day.
In
terms
of
where
you
know,
how
often
does
your
organization
deploy
to
production,
and
it
looks
like
most
folks
that
have
entered
in
there,
their
choices
and
I
think
Charlene.
B
So
it
looks
like
the
majority
of
folks
on
today's
webinar
are
deploying
anywhere
from
once
a
week
to
a
few
times
per
month.
We
have
some
folks
who
are
deploying
multiple
times
per
day
and
we
have
some
folks
that
are
doing
one
release.
You
know
every
six
months
longer,
so
a
spread
across
what
looks
like
most
folks
doing
a
production
to
play
about.
You
know
once
per
week
the
next
question
that
we
have,
if
you
can
pop
that
one
up
Charlene
sure,
are
happy
to.
B
Is
what
are
which
cloud
providers
are
you
using
today,
and
so
something
we're
definitely
interested
is?
Are
you
doing
everything
on
Prem
or
everything
in
a
private
cloud?
Are
you
using
one
of
the
major
cloud
providers?
Let's
say
you
know
Google
AWS
or
Asher,
or
are
you
using
perhaps
another
cloud
provider
and
if
you're
using
another
cloud
provider,
feel
free
to
drop
in
chat
which
which
cloud?
What
are
some
of
the
other
providers
that
you
are
making
use
of
and
certainly
feel
free
to
check
all
that
apply?
B
What's
interesting,
here
is
about
40
percent
of
39
percent
of
folks
on
the
call
are
doing
no
no
public
cloud,
everything
either
on
premises
or
in
a
private
cloud
and
some
other
types
of
cloud
providers
there.
So
that's
definitely
interesting.
Just
a
couple
more
questions
and
we're
gonna
kick
into
our
content.
The
next
question
we'd
like
to
know,
is
about
kubernetes,
and
so
you
may
or
may
not
be
familiar
with
kubernetes.
We
will
be
talking
about
kubernetes
and
give
you
a
full
introduction
today
on
the
call
and
we're
just
curious.
B
Where
are
you
at
and
your
organization,
perhaps
you're,
not
using
or
kubernetes,
not
looking,
not
looking
to
use
it?
Perhaps
you
have
some
plans
to
use
kubernetes.
Maybe
you
have
started
testing
with
it
today
or
maybe
you
are
doing
kubernetes
in
in
your
infrastructure
for
for
production
deployments.
So
it
looks
like
most
folks
have
have
answered
the
poll
there.
Let's
go
ahead
and
show
the
answers
to
the
crew,
so
they
can
also
see
who's
on
the
call.
B
This
is
pretty
interesting
to
me.
It
looks
like
we
have
several
several
folks,
30%,
almost
1/3,
using
in
experimental
or
non
production
environments
and
just
a
few
who
are
not
using
kubernetes
about
20%
22%
or
not
planning
to
use
it.
But
everyone
else
has
some
familiarity
or
is
using
kubernetes
and
looks
like
most
folks
are
either
planning
to
evaluate
it
or
evaluating
I.
Think
you're
on
the
right,
webinar
we'll
be
talking
about
kubernetes.
The
last
question
we
have
is
the
same
question,
but
in
regards
to
server
lists.
B
So
of
course
we'll
be
talking
about
surrealist
today
on
the
webinar,
and
so
the
question
would
be:
where
is
your
organization
at
in
terms
of
serverless
adoption
and
a
similar
question
either
not
using
it
not
planning
to
you,
let's
say
in
the
next
six
months
or
some
level
of
adoption,
and
today
we'll
be
talking
specifically
about
containers
using
containers
with
server
lists.
But
this
could
be
any
service
technology.
B
You
know
lambda
or
Google
functions
where's,
your
organization
at
so
it
actually
looks
like
folks
are,
boats
are
still
coming
in,
I
was
gonna
say
we
could
show
these
results,
but
we'll
give
another
moment
here
and
I
always
think
it's
interesting
when
I
tend
to
join
web
cast
as
well.
You
get
a
you're
gonna
make
above
the
audience,
and
sometimes
it's
a
little
bit
different
than
what
you
expect.
So
we
can
close
this
one
out
and
show
it
to
the
folks.
B
Also
interesting
results,
so
this
one
pretty
split
across
with
only
1%
using
serverless
today
in
production,
so
definitely
on
the
right.
Webinar
we'll
be
talking
about
server
lists
and
if
you're
you
know
evaluating
or
looking
to
adopt
server
lists.
This
is
what
we're
happy
to
share
with
you
today,
so
with
that
I
would
love
to
close
down
that
poll
and
share
a
few
slides
here
just
to
chat
about
what
serverless
is
and
give
a
bit
of
an
introduction,
so
first
just
to
level
set
for
everyone
on
the
call.
B
What
is
serverless
so
really
the
way
I,
Matt
and
I
are
thinking
about.
This
are
in
terms
of
two
components:
an
operational
model
and
a
programming
model.
So
with
the
operational
model,
serverless
is
about
not
needing
to
manage
any
of
your
own
infrastructure,
so
the
traditional
serverless
services
are
things
like
Amazon,
lambda,
Google
functions,
asher
cloud
functions
and
the
idea
here
is
you
write
a
single
function
and
upload
that
into
one
of
these
cloud
providers,
I'll
show
you
what
that
looks
like,
so
this
literally
can
be
as
small
as
a
single
hello
world
function.
B
This
is
an
example
from
Google
cloud
platform
uploading
to
Google
functions,
so
you
write
the
function.
You
can
either
put
it
into
the
web
interface
as
I'm,
showing
here
on
the
screen
or
very
often
what
you
do
is
you
will
actually
zip
up
that
code
and
do
a
zip
file
upload
that
to
the
web,
and
then
all
of
the
operations
is
taken
care
of
for
you.
So
what
the
cloud
provider
does
is
it's
a
vent
driven
when
an
event
comes
in?
They
will
spin
up
the
infrastructure
to
run
that
function.
B
They
will
execute
it
and
then,
if
there's
more
load,
they'll
they'll
process
that
load.
But
if
there's
an
after
a
certain
period
of
time,
usually
like
5
to
15
minutes,
then
it
will
actually
shut
down
that
infrastructure.
What's
really
nice
about
the
server
list
model?
Is
it's
a
paid
only
for
usage?
That
means,
if
your
app
is
getting
hit
with
a
lot
of
requests,
the
cloud
provider
will
spin
up
more
and
more
infrastructure
to
handle
that
load
it'll
scale
for
you
elastically.
B
So
you
don't
have
to
worry
about
loader
any
operations
and
if
there's
no
load
on
your
app,
it
will
scale
all
the
way
down
to
zero.
So
there's
a
lot
of
benefits
here
with
server
less
technology
and
in
particular
serverless
functions.
However,
serverless
is
more
than
just
functions,
often
when
I'm
having
conversations
with
various
folks,
whether
I'm
talking
to
customers
of
good
lab
or
users
or
folks
at
a
conference,
people
tend
to
think
of
serverless
and
equate
it
with
functions
or
functions
as
a
service.
B
What
we
would
call
fast,
but
really
serverless,
is
so
much
more
than
functions.
That's
what
we
really
like
to
talk
about
today.
One
of
the
things-
and
this
is
pretty
common
as
folks
will
say-
functions-
go
together
great
with
managed
services
so
also
in
the
camp
of
serverless.
If
you
are
building
a
serverless
application
or
service
architecture,
it
almost
certainly
will
include
some
type
of
managed
services
again,
usually
from
some
type
of
either.
B
But
if
you're,
if
you're
using
functions,
they
don't
apply
it
for
every
use
case
and
there
are
some
challenges.
So
when
you
start
using
service
functions,
one
of
the
challenges
are:
if
you
have
an
existing
application
and
you
want
to
move
it
into
a
fast
or
functions
as
a
service
platform,
your
existing
app
will
need
to
be
completely
rejected
and
usually
pretty
dramatically,
it's
it's.
You
would
need
to
have
that
shift.
That's
one
of
the
challenges.
B
Another
really
really
big
challenge,
one
that
I
hear
extremely
often
is
that
if
you're
using
fast
there's
a
vendor
lock-in.
So
if
you
write
all
of
your
functions
on
lambda
and
then
later
on,
decide
you
want
to
use
Google
cloud
platform
or
Azure
functions.
Shifting
between
those
platforms
can
be
very,
very
difficult,
especially
the
more
managed
services
you
consume
a
lot
of
times,
they're
very
integrated
and
there's
not
a
lot
of
portability.
It's
just
one
of
the
things
that
comes
along
with
using
functions
from
a
cloud
provider,
there's
not
a
lot
of
portability
there.
B
Another
challenge
is,
if
you
are
used
to
developing
a
certain
way
or
your
engineering
team
is
most
likely
comprised
of
engineers
who
have
a
certain
set
of
development
skills.
Our
contextual
patterns
that
they
understand
programming
with
functions
is
a
whole
new
paradigm
to
learn.
There's
a
lot
of
things
that
you
need
to
do
differently
than
what
you're
used
to
so.
Those
new
paradigms
can
be
a
learning
curve
if
you
haven't
done
them
before,
or
it
can
be
difficult
or
expensive
to
procure.
B
B
Additionally,
one
of
those
challenges
is,
if
you
want
to
do
local
development,
very,
very
difficult
to
do
when
you're
using
functions
as
a
service.
The
reason
why
is
because
you
upload
them
to
the
cloud
service
and
then
all
of
your
different
functions
are
interacting
with
each
other
in
order
to
replicate
that
entire
cloud
service
in
your
local
development
is
very,
very
difficult.
B
It
is
possible,
but
it
requires
a
lot
of
sophisticated
engineering,
usually
setting
some
type
of
stubs,
and
you
know,
data
type
services
that
are
sending
you
back
pre-programmed
responses
and
it's
really
almost
impossible
to
test
locally.
You
could
have
some
types
of
proxies
where
you're
funneling
production
data
down
to
your
local
development.
You
can
see
it's
very,
very
difficult,
very,
very
complicated.
It
is
one
of
the
challenges
of
using
functions.
Is
it's
just
not
going
to
be
local
development
like
you're
used
to?
And
finally
there
are
new
architectural
patterns
to
learn.
B
C
Okay,
hopefully
my
slides
are
coming
through
momentarily
okay,
so
thanks
William.
This
was
a
great
introduction
to
functions.
So
when
we
think
of
Cerberus,
we
tend
to
think
of
pretty
much
functions
and
functions
as
a
services
only
but,
as
we'll
even
said,
containers
actually
give
us
that
opportunity
to
pretty
much
do
whatever
we
want
in
a
way
that
we're
already
used
to
right.
So
first
of
all,
containers
are
portable.
When
you
build
a
container
image,
it
runs
on
iran's
every
word.
The
same
way
you
can
go
from
one
cloud
provider
to
another.
C
Containers
are
flexible,
you
can
use
any
language
framework
or
the
dependency
that
you
like.
If
you
wanted
to
actually
run,
let's
say
a
Fortran
service
on
containers,
you
could
totally
do
that
right
and
finally,
the
containers
are
reproducible,
so
this
gives
us
gives
this
gives
us
that
flexibility
to
have
something
run
locally.
The
same
ways
same
way:
it
runs
on
a
cloud
provider.
So
containers
are
this
thing
that
we
already
had
for
a
while
already.
So
why
are
we
not
using
containers
right?
C
C
Assuming
many
of
you
already
know,
kubernetes
crazes
the
de-facto
platform
for
running
containers
on
a
set
of
machines
that
you
own
and
so
Cabernets
was
initially
developed
at
Google,
and
now
it
is
one
of
the
most
open
source
popular
projects
right,
so
Cabrini's
is
not
optimized
for
service
paradigm,
and
let's
talk
about
that
a
little
bit.
Why
is
kubernetes
not
great,
so
first
of
all,
Green's
does
not
have
this
notion
of
fast
request
based
auto
scaling.
C
Based
activation,
so
if
you
ever
heard
of
the
notion
of
cold
stars,
this
is
what
we're
referring
to
basically
a
request
since
your
service,
and
then
your
service
actually
starts
and
handles
that
request
and
goes
away.
Ideally
after
a
while
and
finally,
kubernetes
does
not
have
this
notion
of
events
and
event
triggers,
like
grenades,
just
runs
containers,
but
it
doesn't
really
know
what
is
going
on
inside
the
container.
It
doesn't
know
anything
about
event
and
service
platforms
like
either
will
Aslam
the
Google
cloud
functions
so
on
and
so
forth.
C
They
know
they
have
this
notion
of
events
which
kubernetes
is
lacking,
and,
finally,
you
need
to
worry
about
actually
operational
aspects
of
running
applications
on
kubernetes,
for
example,
you
need
to
worry
about
networking
load
balancing.
What
is
the
process
lifecycle
like?
How
do
I
do
restarts?
How
many
replicas
do
I
run
at
a
time
like
how
do
I
set
up
auto
scaling
again,
as
I
mentioned
earlier?
How
do
I
do
my
rollouts
and
what
is
the
memory
CPU
that
my
container
should
be
running
with
you
know,
ideally
in
serverless
world
the
service
world?
C
Do
you
worry
less
about
the
operational
aspects
and
you
focus
on
the
code
and
once
you
deploy
your
code,
the
rest
is
pretty
much
taken
care
of
by
the
infrastructure
provider.
So
what
we're
saying
is
that,
at
the
end
of
the
day
and
operators
want
kubernetes,
Careyes
is
great
for
orchestrating
infrastructure
and
micro
services.
You
know
when
we
talk
to
operators,
they
just
want
kubernetes.
They
want
to
have
you
know,
hey
I.
Have
these
machines?
Can
you
manage
them
for
me?
So,
for
example,
we
have
google
kubernetes
engine,
which
is
the
manage
kubernetes
service.
C
We
have
on
google
cloud
people
come
to
google
kubernetes
engine,
they
say,
hey,
give
me
ten
machines
and
they
get
those
ten
machines
that
are
fully
managed
by
Google
cloud.
The
problem,
though,
with
kubernetes
is
it's
not
the
right
abstraction
for
developers
like
if
you're
just
a
software
engineer
writing
code,
you
have
to
go,
learn
a
lot
of
a
lot
about
infrastructure
concerns
and
Kearney's
api,
with
best
practices
about
grenades
and
so
on
and
so
forth.
So
the
computing
is
a
gray
is
not
the
right
abstraction
for
developers
for
sure.
C
So,
on
the
other
hand,
when
we
talk
to
developers
we're
seeing
that
most
of
all
opers
don't
actually
care
about
the
infrastructure
of
operations
at
all,
they
just
want
to
write
code
that
directly
benefits
their
business.
So
they
don't
want
to
be
in
the
business
of
you
know
doing
operations
they
don't
want
to
be
constrained,
you
know
framework
or
language
they
want
to.
You
know
have
that
full
flexibility.
They
want
to
say
you
know,
I
want
to
use
Python
3.
C
My
name
is
Python
to
own
I,
used
Java
8
or
maybe
like
a
Java
version
that
is
from
12
years
ago.
So
they
want
that
flexibility,
while
still
having
something
like
a
high
level
platform
that
lets
them
deploy
their
applications
right
and
finally,
they
don't
want
to
manage
the
infrastructure
at
all.
So
most
serverless
platforms
give
them
that,
like
the
reason
why
people
like
you
know,
platforms
like
Google,
App,
Engine,
Google
cloud
functions,
aw,
slam
de
and
so
on
and
so
forth.
C
The
only
reason
they
like
it
is
you
just
write
your
code
and
the
infrastructure
gets
out
of
the
way.
So
why
can't
we
have
both?
You
know
containers
give
you
that
flexibility
that
you
need,
so
what
if
we
had
an
option
to
run
containers
in
a
fully
managed
infrastructure,
but
at
the
same
time
you
know
we
can't.
We
also
have
containers
run
easily
on
the
infrastructure
that
you
own,
because
most
of
you
are
not
directly.
You
know
running
on
a
fully
managed
environment,
you're,
probably
still
running
virtual
machines.
C
C
So
this
brings
us
to
the
candidate
project.
I'm
gonna
talk
a
little
bit
about
Canada
I'm,
not
gonna,
go
into
too
much
detail,
so
Canada
project
is
last
year
or
something
we
announced
last
year,
along
with
some
partners
like
IBM,
Red,
Hat
and
pivotal.
So
Canada
project
is
an
open
source
building
blocks
for
creating
serverless
experiences
of
kubernetes.
So
what
does
that
mean?
C
First
of
all,
I
can
either
has
an
open
API
that
defines
what
the
server
list
experiences
look
like
on
kubernetes
or
on
any
other
platform,
and
secondly,
it
is
an
open
source
implementation
and
I'm
gonna
explain
that
in
a
little
bit.
So
if
you
are
interested
in
Canada,
you
can
find
more
information
on
kn8
about
that.
So,
let's
see
what
Canada
adds
to
the
table,
all
right
brings
to
the
table.
C
So,
first
of
all,
we
have
an
open
API
on
Canada
Canada
was
trying
to
standardize
serverless
containers
just
like
how
kubernetes
has
standardized
running
containers
kay
here
wants
to
standardize
the
notion
of
having
service
containers
and,
if
kubernetes
cluster,
so
Canada
has
some
properties
that
khorinis
likes.
That
I
mentioned
earlier,
for
example,
scale
to
zero
or
zero
to
n,
which
is
the
fast
request
based
activation
and
scaling,
and
it
has
this
notion
of
event
sources,
event
handling
an
event
delivery.
C
C
So,
let's
talk
a
little
bit
about
cloud
run.
The
cloud
run
is
a
new
product,
that
is
by
guru
cloud,
and
it
is
a
service
compute
platform
to
run
service
containers
and
cloud
room
is
built
from
the
K
native
project
that
I
just
described.
So
we
took
an
open
source
implementation
and
we
pretty
much
implemented
it
in
internally,
so
that
we
can
run
it
internally
and
then
it
uses
the
same
API.
That
is
portable.
C
So
you
can,
you
know,
install
Canada
on
your
kubernetes
cluster
and
it
would
work
the
same
way
that
we
have
cloud
run
on
Google
Cloud
and
we
also
have
an
option
to
run
cloud
run
anywhere.
You
want
so,
let's
take
a
little
bit
into
it.
So
why
is
claire
run
interesting?
First
of
all,
it
lets
you
run
any
language,
any
binary,
any
library,
because
we're
using
containers
right
if
you
wanted
to
run
COBOL
containers
as
a
cert
in
a
serverless
fashion.
C
You
could
totally
do
that
because
the
seconds
it's
its
container
base
and
we
know
that
you
can
install
anything
in
containers,
and
it
has
still
this
paper
usage
model
that
you
have
in
serve
those
platforms
you're
only
paying
when
you're
processing
an
HTTP
request.
So
if
you're
not
running,
if
you're
not
getting
any
requests
and
you're
not
actually
charged,
and
on
top
of
that,
if
multiple
requests
are
actually
overlapping,
you're
not
double
charged
as
opposed
to
some
platforms.
C
Like
you
know,
a
device,
lambda
or
Google
cloud
functions,
they
charge
you
per
request,
but
cloud
run
doesn't
charge
you
per
request.
It
only
charges
you,
while
you're
processing,
an
HTTP
request-
and
certainly
you
know
cloud
run-
can
go
from
running
nothing
to
thousands
of
requests
per
second,
really
really
quickly
like
you
can
be
even
running
nothing
and
next
minute,
you'll
be
handling
10,000
requests
or
more
within
just
a
few
seconds
without
dropping
any
of
the
requests.
C
So
this
is
really
powerful
and
this
is
why
people
really
like
serverless,
you
know
if
you
were
managing
servers
running
from
nothing
to
tens
of
thousands
of
requests,
will
require
you
to
provision
a
lot
of
infrastructure
ahead
of
time.
So
we
don't
have
that
in.
We
don't
have
that
in
cloud
run
or
other
servers
platforms.
And
lastly,
as
I
explained
earlier,
the
cloud
run
really
gives
you
that
option
to
run
option
to
choose
where
you're
running.
So
we
have
two
options
and
I'm
gonna
talk
a
little
bit
about
these.
C
One
is
running
fully
on
Google's
infrastructure,
on
or
running
on,
a
Carini's
cluster
that
you
already
have
or
provided
by
Google.
So
as
I
talk
as
I
said
earlier
on,
the
left
you
were
gonna
see
cloud
run
cloud
run,
runs
your
containers
on
Google's
private
infrastructure.
Like
you,
don't
see
any
virtual
machines,
there
are
no,
you
know,
instances
laying
around
you
just
give
us
the
container,
and
then
we
run
it
for
you.
C
C
I
have
cloud
run
on
GK,
so
this
is
a
flavor
of
cloud
run
that
is
installed
on
top
of
Google
khorinis
engine
clusters,
so
Google
Google,
Currents
engine
is
a
standard,
Korean
distribution
and
then
we
add
an
add-on
called
cloud
run
to
it
and
then
suddenly,
your
careers
cluster
is
supercharged
with
serverless
powers.
So
if
you're
already
using
kubernetes
on
google
cloud
by
enabling
this,
you
get
that
service
developer
experience
of
simply
deploying
containers-
and
you
have
that
you
fast
request
based
activation
and
auto
scaling.
C
C
So
what
is
cloud
run
good
for?
So
let's
talk
a
little
bit
about
this.
If
you
haven't
application
that
does
processing
when
a
request
comes,
Quadron
is
a
great
idea,
so
cloud
run
doesn't
support
background
processing.
For
example.
Let's
say
you
have
an
application
that
wakes
up
every
five
minutes
and
does
something-
and
you
know
just
goes
to
sleep
again
cloud
run-
is
not
great
for
that.
If
you
get
no
requests,
we
actually
throttle
your
CPU
almost
to
zero.
So
there
is
no
background
processing.
C
There
is
only
processing
when
you're
handling
requests
and
the
cloud
run
is
great
for
going
serverless
without
changing
your
code
like
if
you
already
have
a
Python
Java
application
out
there,
you
can
just
put
in
a
container
and
then
suddenly
you're
actually
running
in
a
serverless
fashion,
where
you
don't
have
to
manage
any
of
the
infrastructure
and
you
get
all
that
auto
scaling
capabilities
out
of
the
box.
And
lastly,
let's
say
you
want
to
move
out
of
a
container
based
infrastructure
that
you
manage,
let's
say
Korres
cluster,
because
you
want
less
management,
less
cluster
management.
C
You
don't
want
to
deal
with
managing
virtual
machines.
You
don't
want
to
deal
with
managing
korean's
upgrades
or
operating
system
upgrades
or
you
don't
want
to
deal
with
the
system
dependencies
that
you
have
on
your
environment
and
you
want
faster,
auto
scaling
again.
This
is
like
another
reason
to
move
out
of
kubernetes
to
go
to
cloud
cloud
run.
So.
Lastly,
I'm
gonna
finish
my
presentation
with
a
demo
and
then
I'm
gonna
hand
it
back
to
William,
so
in
this
demo,
I
want
to
show
a
demo
of
what
been
what
we've
been
discussing.
C
So,
first
of
all,
I'm
gonna
walk
you
through
a
legacy
application
and
I'm
gonna
explain.
Why
is
why
is
this
a
legacy
application
and
not
a
Greenfield
application?
And
then
I'm
gonna
explain
how
to
put
that
in
a
container
image
using
docker
and
then
I'm
gonna
go
serverless
from
there.
I'm
gonna
deploy
this
container
to
cloud
run
and
then
I'm
gonna
show
you
how
this
application
runs
on
cloud
drawn
with
on
an
endpoint
that
is
HTTP
and
it's
fully
managed
by
Google
Cloud
and
it
scales
automatically
and
then
I'm
gonna.
C
So
I'm
gonna
exit,
my
presentation
right
here
and
I'm
gonna
walk
you
through
the
application
that
I've
been
mentioning
a
little
bit.
So
this
is
the
PDF
application
that
I
already
have.
As
you
can
see,
this
application,
basically
commerce
stock
files
to
PDF
and
let's
see
how
it
does
actually
so
I-
have
this
Python
application
here.
C
Let's
click
to
it,
and
just
if
this
application
is
basically
down
here,
I
have
a
I,
have
a
function
that
basically
calls
OpenOffice
or
LibreOffice
and,
as
you
know,
livery
office
is
like
10
years
old,
so
fair
and
it's
probably
written
in
C++
and
I'm.
Invoking
this
from
a
Python
application.
So
the
way
I
I
do
that
is
I.
Go
back
and
I'll
show
you
this
docker
file,
which
is
the
file
that
we
use
to
build
containers.
C
So
this
basically
says:
hey
I'm
gonna
use
a
Python
image
and
I'm
gonna,
add
libera
office
to
it
and
a
bunch
of
other
dependencies
that
you
normally
wouldn't
be
able
to
install
on
a
service
environment
and
then,
finally,
you
know
I'm
gonna
run
this
server
application.
So
if
I
go
to
my
demo
environment,
so
this
is
the
Google
cloud
platform
console
if
you're
not
familiar
with
it.
So
let's
go
to
this
PDF
directory
and
the
way
you
build
this
application.
Is
you
type
Tucker
build?
C
And
then
you
basically
specify
where
you
want
to
build
this
image,
and
then
you
know
dr.
kick
saw,
goes
ahead
and
kicks
off
a
build,
so
I'm
not
going
to
wait
for
that.
This
is
the
complete
I
already
build
and
push
the
image
for
the
sake
of
this
demo.
So
now
next
I
want
to
show
you
how
to
deploy
this
to
cloud
run
again.
C
Cloud
run
is
that
environment
that
I
deployed
containers
that
are
HTTP
bays
and
it's
fully
managed
by
Google
I,
don't
have
to
do
any
operations
whatsoever
and
to
show
how
that
actually
works.
I'm
gonna
click
create
service
here
and
I'm
gonna
type,
the
same
container
name
I
just
described
earlier
and
once
I
type
that
it
basically
saves
me.
Where
do
you
want
to
deploy?
Do
you
want
everyone
to
access
it
and
I'm
gonna
check
these
boxes
and
I'm
just
gonna
hit
create
so
once
I.
Do
that?
C
What's
going
on
right
now,
behind
the
scenes
is
that
Google's
managed
infrastructure
is
downloading
my
container
image
and
it's
using
the
infrastructure
that
is
already
provisioned
by
Google
to
serve
this
traffic.
So
you
know
in
less
than
say,
15
seconds
the
applications
actually
deploy
and
I
get
an
HD
fully
HTTP
endpoint
from
Google
and
once
I
click
to
it.
After
a
few
seconds
of
cold
start.
Hopefully
my
application
is
going
to
load.
It
seems
like
you
know.
C
You
wouldn't
be
able
to
do
that
so
now
you
have
that
ability
to
do
this
on
group
Google
cloud
run,
so
it
seems,
like
my
document
has
actually
been
converted
to
PDF.
Just
fine,
so
I'm
gonna
go
back
and
I'm
gonna
show
you
that
here
I
have
this
kubernetes
cluster
on
the
Google
cloud.
Again,
it's
called
the
GK
cluster
and
what
I?
What
I
want
to
show?
You
is
I'm
gonna
click
on
this
cluster
and
I
want
to
show
the
add-on
that
I
mentioned
earlier.
That
is
already
installed
in
this.
C
So
if
I
scroll
down
here
the
basically
says
add-ons
here,
you
see
it
says
cloud
run
on
gke.
So
this
is
that
thing
that
makes
my
GK
cluster
run.
This
cloud
run
applications
the
same
way:
I
run
them.
So
if
I
go
back
here,
go
back
to
my
console
again,
let's
take
this
demo
application
again
and
then
I'm
going
to
deploy
another
service
to
cloud
run,
but
this
time
instead
of
deploying
to
Google's,
managed
infrastructure,
I'm
gonna,
deploy
it
to
the
GK
cluster
that
I
already
have.
C
So,
if
I
go
ahead
here
and
if
I
click
on
the
location,
you're
gonna
see
that
there's
a
US
central
one,
which
is
fully
managed
by
Google,
but
I
also
have
a
GK
cluster
that
I
can
deploy
to
so
the
same
way.
I
deploy
this
application
so
what's
happening
right
now
is
I'm
using
the
same
API
or
same
command
line
experience
or
same
UI
to
deploy
to
both
platforms
and
again
in
a
few
seconds.
C
This
application
is
already
deployed
to
GK,
so
if
I
click
on
the
URL
that
it
gave
me
I
get
the
same
experience
if
I
click
to
the
same
demo,
the
whole
thing
works
the
same
way
because
it's
containers
right.
So
let's
take
a
little
bit
behind
the
scenes
of
what
is
actually
going
on
here.
So
if
I
come
to
my
cloud
console
here,
if
I
say
G
cos
beta
run
services
list,
let's
type,
that
correctly.
C
Buncha
warnings,
you're
gonna,
see
that
I
have
this
PDF
service,
so
if
I
say
g-cloud
betta
run
services
described
because
I
want
to
see
what's
going
on
inside
my
service
and
I'm
gonna
say
I'm
running
on
the
manage
platform,
and
then
my
location
is
your
central
one
and
I
have
this
application
called
PDF.
So
if
I
take
a
look
at
the
output
of
this
command,
I'm
basically
seeing
this
yellow
file,
which
is
oddly
familiar.
It
has
api
version.
It
says
kind
service
as
metadata
if
you
already
use
Karuna
DS.
C
This
is
because
this
is
a
kubernetes
object
running
on
Google's
infrastructure.
So
what
I'm
gonna
do
is
I'm,
actually
gonna
save
this
thing
to
a
file
called
service,
not
yellow,
ok.
So
let's
take
a
look
at
this
service
that
yellow
and
what
I'm
gonna
do
here.
First,
first
and
foremost,
is
I'm.
Gonna
delete
bunch
of
things
that
I
already
don't
need,
so,
for
example,
I'm
gonna
need
all
these
lines
too.
Just
to
show
you
what
is
going
on
here,
alright,
so.
C
At
the
end
of
the
day,
what's
going
on
here
is
that
this
is
a
simple
k-
service
description.
It
basically
says
that
I
have
this
image
and
I
have
this
memory
constraint,
and
you
know
these
are
my
timeouts
etc.
Please
go
run
this
application
for
me
using
the
K
native
API.
So
lastly,
as
I
said
earlier,
I'm
gonna
go
out
and
deploy
this
application
to
IBM's
cloud.
So
if
I
go
to
IBM
cloud
console
here,
you're
gonna
see
that
I
have
a
cluster
here
called
K
native
cluster.
C
Let's
click
on
this,
just
like
you
know
what
I've
been
doing
at
Google
cloud,
I
actually
installed,
K
native
to
IBM
cloud
as
well,
but
I
didn't
do
it
myself,
like
I,
didn't
go
ahead
and
manage
the
scanner
installation
if
I
click
to
the
add-ons
tab
up
here,
you're
gonna
see
that
IBM
cloud
also
has
a
candidate
distribution.
Just
like
Google
Cloud
does
I
actually
went
and
enabled
manage
K
native,
which
gives
me
the
service
capabilities
on
my
kubernetes
cluster.
C
So
you
know
you're,
seeing
that
I
have
the
same
functionality
on
multiple
cloud
platforms
and
it's
open
source
and
it
is
open.
Api
and
it
is
portable,
so
if
I
go
back
to
my
console
here
and
if
I
say
you
know,
if
I
point
my
cube,
CTL
command
to
the
IBM
cluster,
let's
run
you
see,
I'll
get
nodes
here
and
then
you're
gonna
see
that
it
says
I
KS
here,
which
means
IBM,
kubernetes
service
I'm,
actually
right
now
targeting
IBM
cornea
service.
C
So
if
I
go
ahead
and
queue
CTL
apply
this
service,
you
know
that
I
saved
earlier
you're
gonna
see
that
the
service
is
actually
now
deployed
to
IBM
criminais
service.
So
if
I
do
QC
TL
get
services,
I'm
gonna
get
this
domain
name.
That
is
pretty
long,
but
it
is
from
IBM
cloud
and
it
also
works
the
same
way.
C
So
if
I
go
ahead
and
open
a
new
tab
and
deploy
this
application
yep,
if
I
visit
this
application,
I
have
the
same
application
again
the
same
container
this
time
running
on
IBM
cloud,
so
it
took
me
like
five
minutes
to
go
from
something
that
is
that
I
have
locally
to
Google,
Cloud
and
then
to
kubernetes
and
then
from
there
to
I,
went
to
IBM
screw
Bernays
cluster.
So
this
is
for
pretty
much
all
I
wanted
to
show
again
Canada.
B
If
that
is
great
on
it,
and
of
course
this
is
a
phenomenal
developer.
Experience
that
you've
seen
developing
locally
I
want
to
have
my
application
deployed.
I
met
showed
how
to
do
that
through
the
UI,
which
is
just
a
few
clicks,
but
there
are
also
really
nice
command-line
tools
for
cloud
run.
That'll
allow
you
from
your
shell
to
do
these
kind
of
same
deployments
with
just
a
few
commands.
B
Of
course,
at
some
point,
when
you
scale
you
want
to
automate
your
deployments
and
then
you
really
want
terrific
CI
CD,
and
so
what
I
would
like
to
share
is
that
most
folks
are
familiar
with
git
lab
as
a
code
hosting
service.
So
a
lot
of
you
folks
on
the
call,
have
your
code
on
get
lab.
You
saw
an
immense
demo.
The
the
code
that
he
was
deploying
was
hosted
on
github,
well,
I
mean
you
may
not
know.
Is
that
get
lab
also
has
world-class
CI
CD.
B
In
fact,
many
many
analysts
and
enterprises
have
written
about
our
CI
CD
capabilities
as
world-class
CDs.
So
when
you're
ready
to
automate
those
deployments,
Gil
IMS
tremendously
ICD,
what
you
may
not
know
is
that
gitlab
also
has
a
whole
slew
of
other
capabilities.
Everything
from
project
management
through
to
release
management
configuration
even
monitoring
and
security
capability.
So
what
you're,
seeing
on
the
slide
right
now
is
actually
a
screenshot
of
our
homepage.
That
shows
all
the
categories
that
we
have
functionality
in
and
even
some
that
are
coming
up
on
our
roadmap.
B
So
one
of
these
that
you
will
see
is
that
within
our
what
we
call
the
configure
stage
of
the
DevOps
lifecycle,
our
goal
is
to
have
a
single
application
that
covers
the
entire
lifecycle.
We
have
a
server
lists
as
functionality,
and
so
the
get
labs
server
list
is
a
way
for
you
to
actually
have
your
own
functions
as
a
service.
Your
own
fast
or
even
your
own
container
service
built
in
to
get
lab.
B
So
the
advantage
here
is,
if
whether
you
are
using
vanilla
kubernetes
that
you
have
provisioned
yourself
and
are
running
on
your
own
on-premises
infrastructure,
whether
you're
using
kubernetes
that
you've
built
yourself
into
running
on
cloud
infrastructure
or
maybe
using
a
managed
service.
Like
like
IBM
or
gke
that
you've
seen
wherever
your
kubernetes
cluster
is,
you
can
connect
it
to
get
lab
and
get
labs
server
lists
can
actually
deploy
your
code
into
that
into
that
kubernetes
cluster
and
using
Kay
native
will
allow
it
to
scale
up
and
down
as
you've
seen
described.
B
So
what
I
would
like
to
also
kind
of
show
you
this
demo
of
how
that
will
work?
You
can
think
of
your
infrastructure
can
be
anything
from
bare
metal
to
any
cloud
service.
You
are
going
to
have
a
kubernetes
cluster
running
on
top
of
that,
for
the
purposes
of
my
demo,
I'll
show
that
with
gke,
but
it
on
git
lab
it
can
connect
to
any
kubernetes
cluster,
and
this
is
one
of
the
really
powerful
elements
of
this.
These
types
of
technology
is
just
that
portability.
B
You
can
decide
where
you
want
it
to
run,
and
you
are
even
able
to
shift
where
that
runs.
Even
have
it
run
in
multiple
places.
As
multi
cloud,
we
will
be
using
the
Kay
native
API
s
for
the
serving
and
eventing,
and
in
this
case
this
is
what
cloud
run
provides.
I'll
show
you
how
you
can
install
that
via
a
git
lab
or
you
could
use
cloud
run
and
then,
of
course,
get
lab
server
lists
going
to
provide
you,
this
concept
of
functions
or
applications,
whereas
kubernetes
doesn't
have
these
types
of
scaling
capabilities.
B
That's
why
unique
a
native
and
k
native
does
not
have
the
concept
of
a
function,
but
within
gitlab
you
can
actually
write
a
single
function
and
have
it
scale
or
as
you've
seen
a
container.
You
can
have
a
container
and
have
gitlab
server.
Let's
deploy
that
and
that's
what
I'd
like
to
share
with
you
over
here.
B
Potentially
so
here
I
have
a
project
that
I
have
already
set
up
on
yet
lab,
and
you
can
see
this
is
the
same
code
that
you
have
already
seen
in
terms
of
this
PDF
application,
where
it
has
a
bit
of
Python
and
it's
calling
out
to
libreoffice
into
the
conversion.
This
is
the
same
code
that
Alma
has
running.
B
The
only
difference
is
I've
made
a
commit
here
to
add
a
CI
ml
file
and,
as
I
mentioned,
get
lab
has
CI
CD
to
allow
you
to
do
this
automation
and
the
way
that
you
configure
that
CI
CD
is
via
some
simple
gamal,
and
this
is
very
powerful
because
it
means
you
can
version
your
CI
CD
configuration
means
you
can
have
multiple
people
collaborate
in
the
same
way.
You
would
collaborate
on
code,
you
can
roll
forward
and
roll
backward
and
have
accountability
and
auditing
etc.
B
Now
this
get
lab
CI
llamó
file
is
extremely
simple,
and
that's
because
it
is
using
the
get
lab
server
list
template.
So
within
gillip
CI
mo
you
can
import
a
template
and
then
extend
it
if
you'd
like-
and
there
are
several
templates
that
just
come
baked
into
the
lab
and
the
serverless
template
is
one
of
them.
B
So
you
can
see
all
I'm
doing
here
is
importing
or
including
this
serverless
template
and
I'm,
going
to
create
two
stages:
I'm
going
to
have
a
build
stage
of
my
pipeline
and
a
deploy
stage
of
my
pipeline
and
both
of
those
are
making
use
of
a
serverless
image
that
just
comes
baked
in
the
gate,
lab
in
a
nutshell,
get
lab.
Serverless
really
is
the
CIE
ML
templates
and
some
visualization
capabilities
that
I'll
show
in
a
moment.
So
this
is
the
same
code
you're
familiar
with,
and
in
order
to
deploy
this
code.
B
I,
of
course
want
to
connect,
get
lab
to
my
kubernetes
cluster,
so
I'll
go
to
operations,
tab
and
go
here
to
kubernetes
when
I
go
to
add
a
cluster
I
have
a
few
options,
so
one
is
if
you
are
not
familiar
with
kubernetes.
This
is
a
nice
way
to
get
started.
We
have
a
great
integration
with
gke,
where
you
can
literally
sign
in
with
your
google
account
name.
The
cluster
and
get
lab
will
actually
go
and
create
the
cluster
for
you
on
gke.
B
B
B
What
that
will
do
is
not
only
deploy
it
onto
some
input
now
in
my
infrastructure
and
give
me
an
endpoint
URL,
but
here
I
have
some
visualizations
I
talked
about,
so
what
Gil
lab
is
doing
now
is
it's
querying
Mike
a
native
service,
and
it
sees
like
I,
have
an
application
I've
named
it
this
service
and
here's
my
endpoints.
So
if
I
visit
the
endpoint,
you
will
see
here's
the
cold
start.
B
We
talked
about
where,
in
this
case,
it'll
take
anywhere
from
a
few
seconds
to
there's
no
pods
spun
up
right,
there's
no
container
so
from
zero
spun
up
this
container
and
now
here's
the
same
application.
We've
seen
a
few
times
course
now
that
it's
live
and
running
hot,
it
will
spin
up
very
quickly
with
new
requests
and
I
can
go
into
get
lab
and
see
some
of
the
visualizations
on
this
page.
B
So,
for
example,
it
will
show
me
a
request
graph
here
of
those
requests
that
I
just
did
and
there
it
is
using
the
Prometheus
monitoring.
So
this
is
some
one
integration
you
see
between
get
lab
and
kubernetes.
Of
course,
what
we
have
today
is,
if
you
want
to
use
all
of
this
together
with
cloud
run,
you
can
use
cloud
run
on
gke
and
cloud.
One
rule
is
all
your
creative
cluster.
B
When
you
came
to
your
cluster,
when
you
attach
that
cluster
to
get
lab,
get
lab,
will
actually
detect
a
native
and
will
be
able
to
use,
get
lab
serverless
all
running
just
the
way
you've
seen
right
now,
but
in
the
future
we
do
also
have
some
roadmap,
where
we
want
to
enable
you
to
also
be
able
to
one-click
install
Kay
native
on
GK,
of
course,
get
lab.
We
like
to
keep
everything
very
transparent
kind
of
unique,
so
you
can
go
to
our
home
page.
This
is
literally
about
that
get
lab.
B
B
A
Well,
yes,
we
have
gotten
some
great
questions
and
but
there's
plenty
of
time
guys
if
you
have
a
question,
let
me
put
myself
on
webcam.
If
you
have
a
question
for
any
of
our
panelists,
please
go
ahead
and
use
your
GoToWebinar
control
panel
and
submit
your
question.
Okay.
First
one
is,
let's
see,
really
cool
presentation
and
examples,
so
yeah.
B
A
C
Probably
take
that
yeah,
that's
true!
So
that's
a
property
of
Sir
Alice,
although
it's
negative
there
are
cold
starts,
and
that
happens
mostly
because
when
you're
not
getting
any
requests,
you're
not
really
running
anything,
so
it
takes
actually
some
time
to
start
your
application
on
Google
cloud
run.
Specifically,
we
have
optimizations
such
as
we
actually
cache
the
image
so
that
it
doesn't
have
to
be
redownload
'add
when
a
request
comes
in
as
long
as
your
application,
startup
is
pretty
fast.
C
B
I
would
I
would
say
my
general
advice
there
is.
There
are
use
cases
that
are
really
good
for
server
list.
If
something
is
event-based,
one
use
case
I
will
talk
about
as
you
sign
up
a
new
user
and
let's
say
you
need
to
do
some
processing.
You've
they've
uploaded
their
their
image
and
you
need
to
go
crop
that
into
different
sizes.
B
So
that's
kind
of
my
advice,
there
is,
if
it's
a
long-running
service
or
if
it's
a
user
facing
service
just
running
that
in
a
regular
container
on
your
kubernetes
cluster,
is
always
on
service.
That's
a
really
really
good
for
those
workloads
and
for
anything
asynchronous
and
event
based
you're
running
that
on
serverless
awesome.
A
B
So
we
get
we
get
this
question
I
get
this
question
pretty
often
when
folks
kind
of
see
that
that
homepage
image
I
showed
again
they're
familiar
with
gitlab
I
post,
my
code
there
but
wow.
You
do
all
of
these
types
of
things
like
project
planning
and
whatnot,
and
so
the
question
is
usually
I'm.
Let's
say
I'm
already
using
tools
for
that.
Let's
say:
I
already
have
JIRA
for
my
project
tracking
and
let's
say
I'm
already
have
my
pipelines.
Let's
say
in
something
like
a
Jenkins.
B
Can
I
use
git
lab
just
for
my
code
repository
and
the
answer
is
yes,
you
can
in
fact,
at
your
lab.
We
try
to
play
well
with
others,
so
you
can,
for
the
most
part,
use
any
component
of
it
as
a
standalone.
So
what
a
lot
of
folks
even
do
now
is
they
will
use
our
CI
CD
tool
and
they
will
have
their
code
hosted
on
github
or
bitbucket
and
use
git
lab
just
for
the
CI
CD.
B
C
I
can
probably
take
that
so
events
are
stuff
that
are
happening
outside
your
application
and
it
comes
to
your
application.
Essentially,
you
can
think
of
events
like
I,
just
uploaded
a
file
to
a
storage
bucket,
and
then
my
I
want
my
application
to
get
called
when
in
files
a
order
to
a
storage
bucket.
That's
like
the
cliche
example
of
serverless
events,
but
another
example
could
be
like.
C
Let's
say
my
build
has
failed,
so
I
want
a
web
hook
so
that
my
application
should
be
called
when
a
build
is
failed,
so
I
can
do
something
like
maybe
post
it
to
slack
or
positive.
You
know
open
a
ticket,
maybe
something
like
that
or
another
example
of
events
could
be.
Let's
see,
maybe
like
III
OT
is
a
great
example.
When
something
happens
on
an
IOT
device.
You
want
to
do
something
on
cloud.
C
So
if
you're
IOT
device
emits
an
event
says,
let's
say
light
turned
on
you're
white,
you
might
want
multiple
applications
to
get
triggered
when
that
event
happens.
So
events
are
basically
just
a
synchro
actions
that
are
happening
outside
the
application
and
your
application
as
a
result
gets
invoked.
As
a
result
of
that
William,
do
you
have
anything
to
add
no
I.
B
Mean
it's
a
great
description.
You
can
think
of
any
type
of
time.
You'd
receive
an
API
call
or
webhook
is
Ahmet
described
or
ones
that
are
very,
very
common
or
when
you
have
some
type
of
a
queue
processing,
for
example,
uploading
the
the
s3
bucket
or
you
have
you
know
some
some
amount
of
things
in
a
queue
each
time
something
pops
off.
You
can
go
and
process
that
event
with
a
serverless
workload.
I.
C
Think
it
interesting
example
of
events
here
is
I'm.
Gonna.
Add
a
little
bit
is
that
let's
say
a
video
is
uploaded
to
a
storage
bucket
right,
let's
say
you're
getting
hundreds
of
videos.
Normally,
you
would
implement
an
application
that
will
DQ
from
the
event
source,
but
in
serverless
case
what's
happening.
Is
that
you
can?
You
know,
let's
say
100
videos
are
uploaded
at
the
same
time,
you
can
just
spin
off
hundreds
containers
to
process
these
videos
and
then
put
it
back
them
to
storage
again.
A
B
B
One
is
what
we
would
call
a
function
and
what
is
what
we
call
get
a
service
application,
your
the
difference
being
with
the
application
you're
specifying
your
own
container,
as
you
saw
in
our
demo,
we
had
a
docker
file
and
you
specify
that
image
and
then
get
lab
will
just
run
that
and
for
the
purposes
of
that
I
I
would
say
anything
that
you
can't
in
container
eyes.
You
can
run
and
scale
and
I'm
seeing
I'm
a
shaking
his
head
that
it's
going
to
be
the
same
way
on
cloud
run.
Is
that
right
on
that?
B
B
So
if
you
think
of
a
typical
function,
there
tend
to
be
size
limits
on
what
you
can
upload
in
that
zip
file
and
I.
Don't
I,
don't
can't
remember
them
all
they're,
probably
a
little
bit
different
for
the
different
platforms,
but
this
is
another
advantage
of
container
izing
the
workload
as
you
you
get
it
containerized
in
all
of
Libre
Office
and
run
a
PDF
translator.
A
C
The
person
says
sorry
time
for
its
1:13
6,
so
this
is
a
betta
Adon
Adon.
If
you
go
to
the
documentation
it
documents
which
versions
it's
available
on
I
know
that
it's
not
not
available
on
some
of
the
older
versions.
I,
don't
remember
off
the
top
of
my
head,
so
I'm
just
gonna,
say
sorry,
please
look
at
the
documentation.
A
C
So
I
can
quickly
probably
answer
that
can
ativ
can
actually
reuse
containers
and
so
does
the
Google
managed
cloud
run
platform,
so
it
contains
if
your
containers
I
say,
go
application
or
C++
application
that
can
handle
thousands
of
requests
at
a
time.
We
will
send,
however,
many
requests
that
you
want
to
your
container
at
a
time.
C
So,
for
example,
if
you
want
your
container
to
get
only
one
request
at
a
time,
you
will
basically
spin
up
another
container
for
each
request
as
long
as
the
other
one
is
occupied,
but
once
the
other
one
is
free,
we're
just
gonna
reuse
that
what
use
it.
So,
how
does
Kay
native
scale
I
think
the
answer
to
that
is
Kay
native
actual
looks
as
request
metrics.
C
It
internally
uses
Prometheus
and
a
few
other
things
to
keep
track
of
the
requests,
because,
because
all
requests
are
going
through
can
ativ,
it
can
actually
knows
what's
going
on
and
it
can
do
really
fast
scaling
based
on
a
immediate
need
for
scaling.
So
if
it
realizes
it's
in
a
panic
mode,
it
will
add
a
lot
of
containers
for
a
while
and
then
he'll
over
time.
Correct
that.
B
And
some
of
that,
some
of
that
is
configurable
as
well
again,
maybe
for
another
for
another
webinar.
But
you
can't
actually
look
at
Acadia
native
documentation
and
if
you
you
know,
you
are
an
Operations
person
or
this
is
your
bag
of
tricks.
As
you
do
like
administering
crew,
Bernays
cluster
and
applying
yamo
files,
then
you
can
even
kind
of
you
can
configure
and
set
some
pretty
granular
parameters
on
on
how
and
when
Kay
native
will
do
the
scaling
for
you
all.
A
Right
great
well
we're
about
five
minutes
to
the
top
of
the
hour,
so
we're
gonna
go
ahead
and
close
out
the
question
and
answer
period
of
today's
webinar.
We
had
a
ton
of
great
questions
and
if
we
didn't
get
to
your
question,
I
apologize
but
I'm
sure
somebody
from
Google
or
gitlab
will
be
more
than
happy
to
follow
up
with
you
and
get
your
question
answered
so
before
we
close
things
down,
do
want
to
do
the
drawing
for
the
350
dollar
Amazon
gift
cards.
A
So
our
first
winner
is:
let's
see,
Tom
West
Rick,
congratulations,
Tom
next
person,
big
winner
mari
Feder,
Oh,
congratulations,
mari
and
finally,
drumroll.
Please
ich
Kapila!
Congratulations!
Ich!
Thank
you
all
for
being
on
the
webinar
today
and
sorry
if
you
weren't
one
of
our
big
three
winners,
but
maybe
next
time,
maybe
next
time
before
we
close
things
down,
I
do
want
to
remind
the
audience
that
today's
event
has
been
recorded.
So
if
you
missed
any
or
all
of
today's
event
or
if
you
just
want
to
watch
it
again,
you
will
be
able
to
do
so.
A
We
are
going
to
be
sending
out
an
email
a
little
bit
later
on
today.
That
includes
a
link
to
the
event
on
demand
and
the
webinar
is
also
going
to
be
living
on
the
DevOps
comm
website,
so
you
can
always
find
it.
There
just
go
to
DevOps
dot-com,
slash,
webinars,
look
in
the
on-demand
section,
and
it
will
be
right
there
waiting
for
you
so
William
and
Amin.
Thank
you
both
for
giving
such
a
great
presentation.