►
From YouTube: Kubernetes for Everyone - Sendil Kumarn, Uber
Description
The presentation will be structured as follows: What is the problem with running your services at scale? The whole process of building, deploying, service discovery, load-balancing, routing, tracing, auth, graceful failures, rate limits, and more—is cumbersome and involves many moving parts. It is complex and nightmare for anyone running their services at scale. How does K8s help to run the services at scale? Let us explore how the K8s container management system, can simplify many of the operational challenges and it includes how to deploy NodeJS services on K8s. What is K8s and how does it work? K8s is the de facto standard for running containerized applications. K8s groups containers that make up an application into logical units for easy management and discovery. We will deep dive into how K8s is architected and how makes it easy to run services at scale.
A
A
I've
written
a
couple
of
looks
one
on
full
stack
development.
The
other
one
is
on
rust
and
web
assembly.
The
rust
and
web
assembly
is
the
new
one
which
is
written
in
a
cookbook
from
it
that
will
help
you
in
your
rust
and
web
assembly
journey
if
you're
learning,
rust
and
web
assembly
for
the
first
time.
This
group
will
help
you
to
understand
and
you
can
find
the
links
here
below
and
I'll,
also
publish
the
slides
later.
A
To
my
talk,
great,
let's
get
started,
this
will
be
an
introduction
to
give
another
stock
where
we
will
see
why
we
need
kubernetes.
What
problems
does
it
solve,
where
you
can
run
it,
how
it
works
underneath?
So,
let's
get
going,
we
will
start
with
a
simple
hello
world
application.
So
it's
a
simple
express
js
application
which
runs
on
port
3000
and
exposes
the
slash
endpoint
on
accessing
it.
You'll
get
a
string
back,
saying
hello,
it's
very
simple
right
once
you
start
once
the
application
is
ready.
A
Now
we
are
thinking
about
how
to
move
that
into
production.
So
when
you
are
thinking
about
moving
into
production,
then
it's
something
like
docker.
You
can
use
to
containerize
the
application
and
then
move
it
to
production.
It
kind
of
gives
you
a
lot
of
advantages
right.
So
in
a
docker
you
get
a
latest
image
of
node.
You
do
all
the
required
things.
For
example,
npm
install
copying
all
the
files
and
directories
and
then
finally,
once
you've
done
you're.
Exposing
a
port
in
our
case
is
3000
and
a
kickstarter
processor.
A
Once
you've
started
the
process,
docker
will
run
the
process,
but
it
will
not
manage
the
process
so
once
the
process
is
dead
because
of
some
reason
your
nk
application
will
not
be
accessible,
so
docker
will
not
control
that.
On
the
other
hand,
docker
gives
the
portability
and
also
it
completely
abstracts
away
operating
system
and
our
runtime
trigger
related
stuff,
because
you
need
not
worry
about
it
as
long
as
you
have
docker
installed,
it
might
be
any
machine
or
any
operating
system.
You
can
actually
run
your
application
inside
as
a
process.
A
That's
really
awesome
right
and
then
once
you
go
into
production,
you
obviously
will
have
to
scale
your
applications.
If
there
are
a
number
of
users
increasing
and
once
you're
trying
to
scale
the
application
at
the
obvious
next
step
is
putting
a
load
balancer
on
top
of
it
and
then
create
a
multiple
containers.
The
docker
containers
can
be
running
in
multiple
parallely.
Would
a
load
balancer
direct
the
traffic
based
on
the
resourcing
or
round
robin
or
any
method
that
you
choose?
A
Load
balancers
itself
is
a
complex
mechanism,
but
there
are
a
lot
of
tools
that
are
available.
That
makes
it
easier
to
build
a
load
balancer
outside
of
your
system
and
then
control
everything
together,
but
over
the
course
of
project
we
found
out,
there
are
two
different
things
that
we
missed
out
and
we
create
two
different
services
for
them.
In
our
case,
hello,
galaxy
andromeda
these
two
services
exactly
similar
express.js
function,
except
for,
like
some
differences
between
galaxy
and
andromeda.
A
So
once
you
have
done
this,
we
could
follow
the
same
pattern,
create
a
docker
image
for
that
run
it
in
a
docker
containers,
multiple
containers
scale
it
across
and
then
put
a
load
balancer
on
top
through
which
all
the
connections
will
happen.
This
is
fairly
straightforward,
but
these
services
are
not
depending
on
each
other,
they're
completely
segregated
right.
But
what,
if
you
want
to
connect
these
services
together?
How
do
you?
How
do
you
make
the
communication
with
them
happen?
A
For
that?
It's
a
negative
example.
If
you
take,
for
example,
if
hello
world
wants
to
talk
with
hello
andromeda,
you
have
to
understand
the
ip
address
or
you
have
to
know
the
ib
address
of
hello
enter
menu.
You
issue
a
request
to
that
color,
andromeda
and
then
enter
meta
will
give
a
response.
You
get
that
response
and
serve
it
back
to
your
customers.
A
This
is
how
it
should
work,
but
doing
that
in
a
manual
way
is
very
inefficient
and
also
takes
a
lot
of
time
for
us
to
do,
for
example,
if
for
any
reason
we
have
changed
the
iphone
7
up,
then
you
have
to
undeploy
your
hello
world
and
then
deploy
it
again
with
a
new
upgraded
config,
so
they
are
kind
of
interdependent
with
each
other.
So
we
in
the
world
of
microservices
or
whenever
you
talk
about
microservices,
you
want
to
isolate
these
services
completely
to
get
outside,
so
you
have
to
pull
them.
A
Apart
make
sure
there
is
no
interconnection
between
them
and
then
deliver
their
masterpine
services.
That's
how
you
have
to
do
it
right.
So
so
in
the
world
of
microservices,
all
the
three
services
are
completely
independent
and
they
are
abstracted
into
a
single
instance
right
now,
so
there
can
be
hundreds
of
instances
of
hello
galaxy
running,
but
you
can
abstract
them
as
a
single
instance.
So
that's
how
the
microservices
has
to
be
architected
in
a
better
way
right.
So
the
obvious
question
is:
how
do
how
can
we
enable
the
communication
between
them?
A
So
we
can
put
in
something
like
service
to
history,
so
the
role
of
service
registry
is
very
simple.
Whenever
a
service
boots
up,
it
goes
to
service
industry
and
says,
like
I'm
booting
up,
please
it's
have
my
ip
address.
If
anybody
wants
to
connect
with
me,
just
keep
them
beside
your
dress,
so
they
can
connect
with
me
straight
away.
A
In
order
to
have
that,
we
have
to
have
another
service
which
is
called
as
health
checker.
The
responsibility
of
health
checker
is
very
simple:
it
takes
in
all
the
information,
sorry
it
takes
in
the
heartbeat
from
the
different
services
and
then
says
like
whether
services
are
live
or
not.
Whenever
a
service
is
not
sending
a
heartbeat
or
any
information,
it
just
marks
that
service
isn't
not
alive
and
removes
that
entry
from
service
to
history.
So
no
new
services
or
new
service
requests
will
go
to
that
particular
endpoint.
A
That's
great,
but
pen,
service
dice.
You
obviously
need
to
have
a
mechanism
to
restart
them
and
also
to
replicate
them,
and
for
these
two
functionalities
you
might
need
a
couple
of
services,
which
kind
of
looks,
sits
and
sees
what
is
happening
inside
my
microservices
world.
And
how
can
I
change
them
and
you
need
to
have
this
mechanism
and
once
you
have
done
those
things,
all
the
things
are
living
as
a
containerized
application.
So
you
need
a
docker
image
from
where
you
can
pull
the
image
and
then
run
your
application.
A
A
When
you're
communicating,
you
have
to
authorize
certain
things
and
authenticate
certain
things
based
on
the
rules,
you
have
to
have
a
mechanism
in
which,
like
allowing
retries
whenever
an
area
happens
and
also
stopping
resource
hungry,
long
polling
of
processes
using
something
like
timeout
so
overall,
you
might
need
some
kind
of
a
setting
that
lives
outside
of
your
services
and
that
could
control
how
your
services
communicate
talk
with
each
other
and
respond
to
each
other.
So
that
is
the
main
intention
of
having
these
services
right
cool.
A
We
can
have
a
couple
of
service
that
kind
of
lives
outside
and
make
sure
that
everything
is
connected
towards
that
and
then
finally,
we
have
to
have
a
robust
monitoring
system
and
also
some
dashboards
that
is
combined
with
the
health.
Checkers
will
actually
help.
You
help
you
a
lot
over
here
because
they
receive
the
heartbeats
from
these
services.
A
So
you
can
use
those
information
and
then
create
certain
things
out
of
it,
so
create
some
graphs
or
visualizations
out
of
it,
and
then
you
need
to
have
tracing
for
your
services
to
identify
where
the
problem
actually
is
when
something
happens,
and
also
debug.
Those
problems
find
a
way
to
pinpoint
a
bottleneck
in
your
services
and
then
try
to
fix
that
over
a
long
run.
A
A
Even
your
application
has
to
be
highly
available
when
it's
your
code,
but
all
the
other
things
are
like
generic
boilerplate
code,
which
has
to
be
highly
available,
and
you
have
to
maintain
and
you're
going
to
spend
a
lot
of
time
in
doing
that,
and
that's
where
cumulative
actually
comes
into
picture.
Kubernetes
is
an
open
source
project
from
google,
of
course,
and
it
helps
you
to
automate
the
deployment,
scaling
and
also
management
of
different
applications,
and
all
these
applications
has
to
be
containerized.
A
A
We
will
just
describe
it
in
the
form
of
animal
valve,
so
you
provide
an
aml
file
to
the
kubernetes,
and
this
aml
file
will
clearly
specify
the
running
state
of
the
application
so
like,
for
example,
if
you
have
some
ml
files,
you
can
just
go
ahead
and
take
a
look
at
it
and
it
will,
if
you
have
some
kubernetes
configuration
files
which
is
written
in
yaml,
of
course,
so
you
can
just
go
ahead
and
take
that
file
and
see
like
what
is
currently
running
in
the
system.
How
many
replications
are
running?
A
A
So
all
the
ml
files
will
start
with
an
api
version,
irrespective
of
any
object
model.
The
ml
files
will
have
an
api
version
number
at
the
beginning.
So
here
we
have
api
version
as
version
one
and
then
for
this
particular
model
we
have
a
spec
inside
the
spec.
We
actually
define
whatever
the
things
that
is
required.
It's
basically
the
custom.
Our
application
related
stuff
will
end
up
there.
So
here
inside
the
spec,
I
put
up
seven
containers
inside
the
containers.
A
I
have
my
hello
world
image
which
we
filled
previously,
so
I'm
just
gonna
use
that
image
and
then
use
a
container
port
80
to
expose
these
things.
Okay,
that's
pretty
simple!
So
you
have
this
docker
image
inside
and
then
you
add
in
what
kind
of
file
it
basically
is
so
the
time
basically
here
determines
the
cumulus
object
here
in
this
case,
you're
defining
it
as
a
spot.
So
what
is
a
bond?
What
is
a
container
that
contains
more
than
one
docker
content?
You
can
have
one
or
more
than
one
docker
container
inside
it.
A
So
it's
a
grouping
of
containers,
that's
where
the
name
port
comes
from,
and
kubernetes
cluster
knows
how
to
manage
the
lifetime
of
these
spots.
So
what
it
does
is
like
it
goes
in
a
three
stage
process
in
the
beginning.
It
starts
the
waiting
process
where
it
sits
and
pulls
the
image
it
does
all
the
necessary
mandatory
work
before
running
this
images.
It
does
everything
together
and
then
assigns
an
ip
address
to
that
particular
part,
and
then
it
also
has
something
called
a
straightness
probe.
A
Once
everything
is
done,
your
application
goes
into
a
terminated
state
where
the
application
is
existed,
exited
and
enclosed.
Here,
cumulus
actually
waits.
If,
if
exit
happens,
naturally
I
mean
like
if
the
exit
happens
intentionally
cumulus
will
just
leave
it
out,
but
if
the
exit
is
happening
because
of
some
errors
or
because
of
something
else,
humans
will
try
to
reinstantiate
the
pod
and
then
goes
through
the
same
life
cycle
again
and
also
every
kubernetes
object
that
you're
defining.
You
can
add
a
metadata
in
the
metadata.
A
You
can
have
key
value
first,
for
example,
here
I
have
a
labels
inside
the
labels.
I
have
app
and
logo.
So
this
kind
of
helps
me
to
have
one
more
level
of
grouping
my
components
I
can
have
different
parts
and
then
group
them
with
different
label
like,
for
example,
environment
production
and
then
apply
sedan
configurations
only
for
that
group.
So
that's
where
metadata
helps
you
out.
It
gives
another
grouping
mechanism
for
you
to
group
things
together
and
then
deploy
them
and
then
have
a
value.
A
A
You
can
group
this
deployments
and
the
pods.
Oh
sorry,
you
can
group
this
replica
set
and
the
bots
together
and
you
can
call
it
as
deployments
so
deployments,
actually
provide
a
desired
state
of
the
application.
It
also
helps
you
to
do
seamless,
rollout
and
roll
back
together,
so
there
might
be
sending
components.
For
example,
your
your
database
server
and
your
application
always
goes
in
together.
So
if
one
of
them
goes
out
of
business,
you
can
actually
delete
the
other
one.
Something
like
that
right.
So
you
can
group
them
together
with
deployments
and
say
like
okay.
A
So
this
my
application
and
the
database
server,
I
want
to
fire
up
the
cars
and
then
group
them
together
and
that's
what
deployment
is
all
about.
Kubernetes
also
provide
one
more
level
of
no
aggregation,
which
is
called
as
name
space
name
space.
You
can
consider
namespace
as
a
folder
inside
which
you
put
all
your
components
inside,
so
you
have
10
teams
in
your
company.
A
So
in
a
more
pictorial
way,
you
have
this
cubicles
cluster.
You
can
have
a
name
space
inside.
You
can
have
multiple
name
spaces
inside
and
then
you
can
inside
the
name
space.
You
can
have
multiple
deployments
inside
a
deployment.
You
have
multiple
ports
inside
the
box.
You
have
to
have
multiple
containers.
So
that's
how
you
build.
This
is
kind
of
architected.
A
But
you
have
the
sample
file.
Now
you
have
to
run
this
inside
equivalence.
We
know
how
to
we
know
what
are
the
basic
elements
inside
ml
file,
but
how
we
can
run
this
inside
this
and
to
see
that
let's
take
a
division
and
go
through
its
architecture
of
cuban,
it
is
how
it
is.
Actually
cuban
is
actually
designed
in
a
cluster
format.
It's
a
highly
available
cluster.
Of
course
it
has
a
control
plane
that
kind
of
controls,
everything
that
happens
in
the
kubernetes
by
the
humanities.
A
A
So
basically
it's
called
as
brain
of
the
equivalence,
cluster
or
brain
of
the
humanities,
and
then
the
worker
nodes
is
actually
where
your
application
level
and
actual
work
happens.
So
you
have
this
yaml
file.
You
send
this
to
control
pane
inside
the
control
plane.
You
have
an
api
server
that
takes
this
file
and
then
validates
it,
whether
it's
perfect.
Well,
it's
correct
yeah.
Even
before
that
you
can
send
your
business
in
three
different
ways.
A
One
is
via
cli,
as
you
have
seen
here,
there's
a
cube
ctrl,
which
is
a
command
line
tool,
so
you
can
use
cube
ctl,
create
dash
of
actor
gamble
which
actually
pushes
this
information
via
cli.
You
can
also
do
it
via
rest,
api,
endpoints
or
you
can
also
do
with
dashboard,
which
gives
a
ui
for
creating
these
things.
So
it
goes
to
api
server.
Api
server
actually
validates
them
once
it
is
validated,
it
gets.
The
information
from
the
etcd
database
so
etc.
A
A
It
combines
all
the
information
that
it
has
the
current
state,
which
is
from
the
adcb
database
and
the
new
configuration
that
you
have
added
it
wraps
them
together,
plus
the
no
details.
The
no
dealers
here
refers
to
the
worker
node,
which
we
will
see
so
it
passes
all
those
things
in
and
then
pushes
into
shader.
A
Shell
is
a
queue
it
works
on
first
and
first
out.
Whenever
something
comes
into
it,
it
goes
ahead
and
tries
to
schedule
it
on
the
work
and
note
before
scheduling
it.
It
has
to
ensure
that
all
the
requirement
that
you've
asked
is
actually
available
in
one
of
the
worker
node,
for
example,
you
can
go
ahead
and
specify.
A
I
want
this
particular
type
of
volume
for
my
humanoid
pod,
so
scheduler
takes
those
into
category
and
those
into
consideration
and
then
finds
a
worker
node
that
is
best
suited
for
the
work
and
then
calls
the
work
and
also
it
says
I
goes
and
says,
work
or
not.
Hey.
Can
you
start
the
work
over
here
so
once
that
happened
inside
the
worker
node,
the
working
load
is
actually
made
up
of
container
runtime
and
the
container
runtime
is
nothing
but
something
like
docker
runtime
right.
A
A
So
you
pass
in
this
few
studio.
Information
to
the
control
plane
and
the
control
plane
will
actually
forward
that
to
the
vocal
node,
but
inside
the
worker
node.
There
is
another
thing
called
node
agent
or
a
cubelet.
This
is
basically
as
a
connection
between
the
control
plane
and
broken,
so
it
sends
information
to
the
control
plane
as
well
as
it
gets
the
information
from
the
control
plane.
So
once
the
scheduler
says
like
this,
worker
node
has
a
capacity
to
run
this
requirement.
A
It
passes
that
information
to
the
node
agent,
which
is
a
cubelet
and
cubelet,
will
proceed
with
the
verb.
So
going
back
to
the
first
line
once
start
work
command
is
issued
to
the
worker
node.
The
workload
actually
does
the
job,
and
then
it
returns
even
before
finishing
the
job
like
everything
is
fine.
A
Apart
from
all
these
components,
control
plane
also
had
some
crucial
components,
just
called
as
control
manager,
which
actually
does
a
lot
of
work.
For
us,
the
control
manager
is
one
that
runs
continuous
loops
to
ensure
the
current
running
state
of
the
cubitus
cluster
is
actually
equal
to
the
desired
state
that
you
have
defined
in
your
yaml
files.
So
it
is
a
one
that
ensures
if
you
have
defined
five
replicas,
all
the
five
are
running:
that's
the
job
of
this
control
manager
and
then
inside
the
worker
node.
A
Of
course,
all
the
worker
node
has
your
application.
That
is
running
your
containers
that
are
running
and
it
has
to
ensure
there
is
a
mechanism
for
having
a
communication,
and
that
is
achieved
with
the
help
of
q
proxy,
so
q
proxy
helps
to
do
the
pawn
to
port
communication
part
outside
world
communication,
and
things
like
that,
and
finally,
you
have
this
add-ons,
which
is
another
whole
suit
of
tools
that
is
helpful
for
you
to
do
it
and
you
can
manage
them.
A
Like
for
and
dashboards
and
monitoring,
so
you
can
use
them
together.
So
this
is
how
an
entire
application
that
interior
cuban
list
looks
like
in
a
very,
very
high
level
view
right.
So
that's
these
components
with
which
they
talk
with
each
other
and
then
take
schedule
and
then
create
your
application
container.
A
Inside
this
component,
the
api
server
is
actually
you
can
have
the
system
very
highly
available
component
and
there
can
be
multiple
instances
of
api
server
running
and
it
is
basically
to
ensure
like
if
something
goes
wrong
or
something
goes
over.
The
picture,
the
the
other
api
servers
can
hit
start
and
start
doing
the
connectivity.
It's
also
very
important
to
note
api
server
is
the
only
one
that
can
connect
to
utc
database
on
any
database.
A
A
A
You
will
not
have
any
information
about
the
cupid's
cluster
there,
so
intcd
database,
you
can
pull
them
out
and
then
use
them
together
later
sorry,
you
can
move
the
cdcd
database
outside,
because
when
your
cluster
goes
down,
all
the
information
about
the
cluster
also
goes
down
with
the
adc
database.
But
if
you
have
it
running
outside,
you
can
actually
recreate
the
same
cube
in
this
instance.
Even
if
it
fails,
you
can
create
a
complete
new
cluster
and
use
the
ctcd
database
as
a
source.
A
That's
how
powerful
kubernetes
is-
and
you
can
also
have
this.
You
know
a
drill
down
version
of
quote
on
limit
management.
So,
for
example,
on
the
right
hand,
side
you
can
see
you
can
breakfast
for
a
set
of
memory
and
a
cpu,
and
also
you
can
limit
your
memory
and
cpu
to
the
maximum
that
you're
going
to
use
for
your
containers.
A
So
you
can
have
this
level
of
you
know
quota
and
limitations
at
the
container
level
at
the
pod
level,
at
the
deployment
at
the
name
space
at
all,
the
levels
like
you
can
have
it
drill
down
or
at
high
level.
So
you
can
have
all
those
required
steps
for
you,
so
you
have
this
cube,
ctrl
file.
You
want
to
apply
this
to
the
kubernetes.
A
You
have
done
it,
so
what
does
it
solve
once
you
put
it
inside,
based
on
whatever
we've
seen
the
pod
replication
controller
replica
sets
and
deployment
kind
of
addresses
all
the
problems
with
the
tick
mark
over
here?
So
you
can
do
this
image?
Pulling
policy
parts
actually
take
care
of
life
cycle
if
something
goes
down,
controller
manager
does
the
restart
and
replication
part.
A
So
cuban
just
kind
of
solves
these
problems,
and
the
most
important
thing
in
the
world
of
microservices
is
how
the
communication
between
services
happening
and
service
registry
is
very
essential.
So,
let's
see
how
cuban
risk
actually
solves
it,
so
kubernetes
has
an
object
model
called
the
services
that
helps
you
to
address
all
those
connectivity
or
depart
for
the
external
and
or
to
other
cluster
communications.
A
So
you
have
a
pod.
Of
course
a
port
can
have
multiple
containers
inside
that
they're
running
inside
and
it
can
came.
It
can
have
antibiotics
actually
enable
spot
support
communication,
so
you
can
have
abstraction
on
top
of
this
board
and
call
it
as
a
service
so
servers
as
you
can
see
in
the
aml
file.
It
comes
with
a
kind
service
you
put
in
a
metadata
and
labels
for
the
servers,
and
then
you
specify
where
the
service
has
to
obstruct
or
what
the
service
has
to
understand
see.
A
Here
we
are
abstracting
on
our
labels
or
the
selector
app,
although
well,
which
were
used
in
the
first
part,
an
example,
and
then
it
also
specifies
the
protocol
in
port.
So
if
you
have
just
applied
that
particular
file,
which
you
have
shown,
it
creates
a
server
subtraction
in
front
of
the
port
and
then
it
assigns
an
ip
to
it,
but
this
ip
can
be
used
only
within
the
cluster.
It
cannot
be
used
outside
of
the
cluster.
A
So
in
order
to
access
this
from
the
outside,
you
can
go
for
something
called
as
the
type
node
port
over
here.
The
type
node
port
is
basically
a
science
dynamic,
node
port
to
the
ip
address.
So,
for
example,
here
I
put
in
my
target
port
is
like
32765
and
this
board
is
attached
for
my
service.
So
if
I
have
to
access
the
service,
I
can
call
my
worker
node,
get
its
id
and
then
go
for
the
node
port,
combine
them
together
and
then
access
it.
A
Cumulus
also
provide
the
same
request:
configuration
where
you
can
abstract
one
level
more
and
create
an
ingress
ip
that
takes
care
of
handling
all
the
breakfasts
that
are
coming
in
and
then
pass
this
and
pass
this
request
to
the
service
and
then
back
into
the
port
and
then
get
the
information
back.
So
you
can
use
ingress
for
external
access,
which
is
the
common
production,
ready
access
right
so
with
services.
A
A
I
would
not
say
humans
is
100
perfect
service
to
industry,
but
it
kind
of
helps
you
to
achieve
the
basic
level
of
service
registry
once
it
is
done.
The
other
components
that
you
have
seen,
which
is
like
the
retries
timeout
settings
and
authorization
and
authentication
kubernetes,
does
not
provide
a
complete,
intimate
solution,
but
you
can
use
something
like
istio
or
linkery.
They
are
called
as
service
meshes.
That
kind
of
helps
you
to
apply
these
configurations
outside
of
the
envelope.
A
So
you
can
consider
this
analogy
where,
like
you,
have
a
big
chunk
of
land
or
a
server
rack,
and
then
you
give
the
server
out
to
given.
It
doesn't
say
like
for
my
components
for
my
services
in
it
and
kubernetes.
Does
that
for
you?
So
you
need
not
worry
about
like
infrastructure.
How
much
memory
to
add
what
are
the
things
that
I
have
to
do?
Humanities
actually
does
all
those
things
for
your
box,
so
it
decouples
the
infrastructure
completely.
A
It
solves
most
of
the
micro
services
common
problems
and
also
also
it
provides
a
platform
to
ship
awesome
things
like
previously
before
containers.
It
was
difficult
for
us
to
stack
away
from
certain
things,
but
give
it.
This
provides
a
whole
new
sort
of
abstraction
with
which
you
can
ship
awesome
things
to
everybody
with
that.