►
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
This talk will focus on usability, and how current tooling like kubectl and YAML often falls short of serving an app developer’s goals. Speaking to NetApp’s work on ALM, in addition to touching on other recent developments in the ecosystem:
CNAB
Dockerfiles
OAM/Rudr
Buildpacks (what we use)
Helm
Serverless
KSonnet, and other templating systems like Isopod
A
Okay,
I
think
we
can
get
started
hello.
Everyone
I'd
like
to
thank
everyone.
Who's
joining
us
today.
Welcome
to
today's
CNC
webinar
Yama
is
optional,
exploring
an
app
developers,
kubernetes
options,
I'm
Karen,
Chiu
community
program
manager
at
Microsoft
and
cloud
native
ambassador
and
I'll
be
moderating.
Today's
webinar
we'd
like
to
welcome
our
presenter
today,
Paul
Burt
technical
product
marketing,
engineer
at
Mehta,
just
a
few
housekeeping
items
before
we
get
started
during
the
webinar
you're,
not
going
to
be
able
to
talk
as
an
attendee.
A
So
if
you
do
have
something
to
ask,
there's
a
Q&A
box
at
the
bottom
of
your
screen,
please
feel
free
to
drop
your
questions
there
and
we'll
get
through
as
many
as
we
can.
At
the
end.
This
is
an
official
webinar
of
the
scenes.
Yes
and
as
such
is
subject
to
the
CNC
F
code
of
conduct.
Please
do
not
add
anything
to
the
chatter
questions
that
would
be
a
be
in
violation
of
that
code
of
conduct.
A
B
B
Look
at
why
Emma
was
seen
as
somewhat
of
a
tragic
tool
that
we're
forced
to
use
in
this
space
and
then
we're
gonna
return
to
the
dev
perspective
and
kind
of
highlight
some
of
the
things
that
they
lost
when
they
made
the
transition
over
its
container
technologies.
After
that
is
the
big
chunk
of
this
presentation.
B
We're
gonna
explore
some
of
I
guess
a
smattering,
a
tasting
plate
of
some
of
the
developer,
oriented
options
and
then
we'll
end
with
a
summary
at
the
end,
naturally
I
suppose
so
you
know
before
containers
we
all
lived
in
a
world
similar
to
this.
We
may
have
deployed
a
node.js
application
and
in
order
to
simplify
things,
our
production
or
operations.
Engineers
may
have
told
us
to
pin
to
a
specific
version
of
node
this
complicated
things
and
that
the
libraries
are
the
modules
that
we
depended
on
sometimes
didn't
support
those
versions.
B
B
Think
of
the
benefit
of
containers,
as
taking
this
phrase
hell
is
other
people.
Hell
is
other
people's
development
environment.
So
for
me,
one
of
the
big
things
that
containers
solved
is
this
conflict
that
we
have
of
things
working
locally,
but
not
working
in
production.
You
know
it
doesn't
solve
everything
under
the
Sun
there,
but
it's
one
of
the
biggest
features
of
a
container
based
workflow,
where
things
are
isolated
neatly
and
packaged
up
very
nicely.
B
So
we
can
convey
the
mover
it's
a
folks
on
the
other
side
of
the
team
that
our
help
must
run
our
systems.
The
advent
of
containers
have
come
and
coincide
with
a
couple
other
things
that
popped
in.
So
you
know
some
of
the
difficulties
that
we
experience
are
certainly
not
only
due
to
container
some
of
its
doot-doot
the
advent
of
cloud
computing.
B
You
know,
micro
services
are
another
thing
that
that
containers
tend
to
be
aligned
with
so
transitioning
to
those
philosophies,
in
addition
to
the
transition
to
containers
and
kubernetes
can
be
part
of
the
complexity
that
gets
added
in
when
we
look
at
what's
required
to
move
to
this
container
native
or
cloud
native
mindset.
So
one
thing
that
developers
lose
is
things
like
hot
reloading,
so
if
you're
a
node.js
developer,
as
in
our
example,
node
Hmong
is
a
very
popular
application
for
hot
reloading,
your
application.
B
Docker
files,
which
you
know
you
might
say,
is
not
that
much,
but
it
is
just
another
little
nudge
in
the
direction
of
complexity
and
difficulty
compared
to
not
having
to
think
about
all
this
stuff,
and
then
you
know
otherwise
it's
just
a
lot
of
tools
had
to
be
replaced
to
work
with
containers
in
this
new
mindset.
So
you
know,
kubernetes
has
been
called
the
Linux
of
the
cloud
and
that's
just
because
back
in
the
day
we
might
have
talked
about
the
lamp
stack,
which
was
Linux
Apache.
B
My
sequel,
PHP
Linux,
was
part
of
the
base
layer
that
we
targeted
kubernetes
is
sort
of
becoming
that
new
base
layer
that
we
target,
and
would
that
means
having
to
learn
everything
that
kubernetes
brings
along
with
it.
So
that
can
complicate
things
a
little
bit
if
we're
developer,
just
trying
to
get
our
app
running,
not
hoping
to
you
know,
delay
things
too
much.
Most
of
what
developers
tend
to
be
interested
in
is
velocity
when
it
comes
to
speed
and.
B
You
I'm
not
gonna,
try
and
convince
you
of
all
of
the
things
that
are
a
struggle
with
Oh.
Instead,
I'm
gonna
rely
on
more
prominent
voices
than
myself
to
make
that
plea.
I,
like
particularly
Joe
Beda
here,
one
of
the
creators
of
kubernetes,
saying
that
it's
tragic
that
yamo
is
sort
of
the
thing
that
we
all
work
with
and
also
like
brian
miles
and
kelsey
Hightower's.
B
Take
here
and
particularly
calling
llamo
could
been
Enys
assembly
code
in
that
it's
an
intermediate
sort
of
value
between
what
humans
can
understand
well
and
what
machines
can
understand
well,
but
that
compromise
ultimately
means
no
one
is
fully
happy
with
how
yeah
Milles
working
so
I
think
Brian
is
totally
right
here
in
that
yeah
mo
asks
for
a
higher
level
constructs
to
help
you
sort
of
manage
it.
A
particularly
good
example
of
some
of
the
challenges
of
llamo
you'll
you'll
note
that
this
is
just
a
couple
weeks
back
October
9th
9th
2019.
B
There
was
a
recent
CVE,
those
discovered.
So
this
comes
from
a
chain
of
attacks
that
I
think
have
been
known
in
the
XML
world.
Basically,
when
you
have
a
a
markup
language
that
allows
you
to
use
anchors
or
things
that
reference
other
things
you
can
wind
up
with
a
recursive
set
of
references
as
pictured
here
that
when
a
server
tries
to
process
can
quickly
sort
of
spike
the
CPU
to
a
hundred
percent
and
that's
exactly
what
was
happening.
B
There
was
a
a
part
of
the
API
server
that
was
going
to
process
and
look
at
the
mo
file
before
actually
validating
that
someone
should
have
access
and
yeah.
It
caused
a
big
issue
in
the
community,
so
you
likely
updated
your
kubernetes
cluster
recently
as
a
result
of
this
attack
being
announced,
I
particularly
again
enjoy
Joby
does
take
on
this.
You
know,
I,
think
he's
thinking
in
the
open
here
asking
other
people
to
help
him
brains
more
than
you
know
punching
down
at
yamo,
but
he's
asking
the
question
to
really
explore
the
space.
B
Is
there
a
way
we
can
eliminate
yamo
as
a
problem
here?
These
extra
features,
these
higher-level
features
that
llamo
has
baked
in
complicate
things,
as
demonstrated
with
the
recursiveness
there
and
I
I
liken
this
to
Jo,
essentially
suggesting
that
we
nuke
everything
and
start
over.
It's
it's
obviously
not
plausible,
but
it
is
an
interesting
sort
of
experiment
to
think
about.
What
could
we
do
if
we
didn't
have
to
interface
with
gamal
and
then
sort
of
where
we're
gonna
go
as
we
look
through
the
rest
of
the
stuff
in
this
space,
so
I
think
really
summarizing.
B
That
kubernetes
is
fantastic.
We
all
love
it
because
it
solves
an
inherently
complex
problem
for
us.
Distributed
systems
are
hard.
Some
of
that
complexity.
Kubernetes
resolves
some
of
it.
Is
you
know
it's
it's?
What
Fred
Brooks
would
call
a
central
complexity,
it's
it's
its
inherent
to
the
problem
space
and
very
difficult
to
remove
without
sort
of
a
leaky
abstraction-
and
you
know
just
looking
at
the
amount
of
resources
that
an
average
user
of
kubernetes
has
to
get
familiar
with
and
think
about
when
they're
deploying
something
to
a
kubernetes
cluster.
B
It's
it's
very
clear
to
see
how
overwhelming
and
demanding
this
is.
So
it's
understandable
when
people
completely
and
on
Twitter
and
in
slack
and
over
coffee
about
how
how
much
of
a
pain
kubernetes
is.
Why
do
people
do
this
to
themselves?
Well,
they
may
not
have
experienced
the
challenge
of
running
distributed
systems
without
kubernetes,
but
you
know
it's
still
a
fair
criticism
that
the
introduction
of
kubernetes
and
asking
them
to
get
on
board
with
containers
and
kubernetes
is
as
part
of
what
is
challenging
for
them.
So
I
call
this
space
shuttle
design.
B
You
know
kubernetes
is
designed
to
a
very
fine
precision
and
it
protects
you
from
the
hostile
environment
of
the
distributed
system.
Space
distributed
systems
are
very
difficult
to
do
correctly
if
you've
studied
paxos
or
looked
at
rafts
sort
of
the
history
that
brought
those
algorithms
into
our
our
domain
of
knowledge.
It's
been
pretty
burdensome
to
work
with.
Those
raft
is
actually
a
way
to
simplify
and
make
paxos
approachable
for
us
mere
mortals
working
in
distributed
systems.
So
kubernetes
is
our
space
shuttle.
B
It
is
our
vehicle
that
is
taking
us
to
a
hostile
land
and
keeping
us
alive
there
and
allowing
us
to
flourish.
But
space
shuttles
are
complex.
Space
shuttles
are
not
like
our
remotes
for
our
TVs,
the
modern
remotes
that
we
work
with.
Rather
the
old-school
remotes
are
something
else,
but
as
a
developer
or
just
a
human
being,
we
tend
to
prefer
designs
like
this
that
we
think
are
elegant
and
sleek
and
there's
not
a
lot
of
learning
curve.
B
We
can
infer
from
context
what
was
expected
on
every
screen
and
that
can
guide
us
through
the
process.
Looking
at
the
list
of
kubernetes
objects,
that
is
obviously
relatively
difficult
to
infer
from
just
context.
You
have
to
do
a
bit
of
studying,
so
in
order
to
solve
those
problems
most
applications
these
days
are
targeting
yamo.
B
Some
are
targeting
the
CIA
CD
workflow,
so
that
it
can
be
your
your
source
of
truth
and
often
a
lot
of
these
solutions
span,
sort
of
multiple
problem
domains
and
what
they're
trying
to
address
but
yeah
at
the
end
of
the
day.
It's
really
we
have
to
figure
out
all
of
these
things
for
developers
coming
onboard,
the
kubernetes
and
I
think
for
the
most
part,
none
of
these
issues
are
really
solved
out
of
the
box
for
them
to
some
of
them.
B
So
most
of
these
solutions,
kind
of
run
on
a
spectrum
I
like
to
think
some
making
Emma
suck
less
by
filling
in
default,
values
or
minimizing
the
amount
of
fields
you
have
to
enter
in
manually.
They
give
you
tools
or
dsls
or
command-line
options
to
automatically
sort
of
parse
data
and
make
things
magically
work
and
others
are
pools
that
are
a
little
bit
more
opinionated.
B
They
obviate
some
of
the
more
complex
things
that
limits
your
freedom
of
action
at
the
end
of
the
day
as
a
developer,
but
it
also
means
you
can
get
more
close
to
that
push
button
workflow
and
what
works
best
for
your
organization
and
your
developers
is
wholly
up
to
you,
but
I.
Think
in
general,
the
kubernetes
distributions
that
we've
been
consuming
and
downloading
haven't
been
getting
very
opinionated
in
this
way.
B
So
it's
it's
a
little
tragic
that
developers
are
left
to
the
the
whim
of
their
operators
or
their
organization,
giving
them
the
time
to
customize
their
kubernetes
in
such
a
way
that
it
can
really
serve
them
under
this
form.
So
let's
look
at
some
of
the
tools
that
are
available
to
us
to
simplify
this
game,
open
on
Durham.
B
So
the
one
that
I
know
the
CNC
F
has
done
webinar
on
recently
I
think
it's
also
been
donated
to
the
C&C
F
sandbox,
its
brigade,
on
its
from
the
folks
who
started
Deus
and
eventually
moved
into
Microsoft's
and
like
shout
out
to
them
for
being
some
of
the
first
people
to
really
think
about
developer
workflows
in
the
kubernetes
space.
I
like
this,
the
brigade
homepage,
just
because
they
are
literally
advertising,
leave
your
llamo
at
home.
One
thing
to
note
here
is
what
they've
done
is
they've
introduced
a
JavaScript
based
DSL,
so
this
domain-specific
language?
B
You
know
you
could
argue
that
maybe
it's
not
as
declarative
as
you
would
like
it
to
be.
I'm
gonna
argue
that
it
is
okay
and
actually
totally
natural
to
mix
procedural
or
some
imperative
tools
with
declarative
software
and
I'll.
Give
you
the
example
of
you
know
every
developer
out
there
who
runs
a
query
on
sequel
and
then
downloads
the
results
of
that
query
into
Python
and
continues
to
shape.
B
You
know
the
results
in
Python
I,
think
that
is
a
accepted
and
fruitful
way
to
work
with
things
and
what
a
lot
of
these
tools
are
doing
is
trying
to
figure
out
where
the
right
boundaries
are
for
the
declarative
piece
and
the
imperative
or
procedural
piece.
So
this
is
cool
the
the
idea
behind
using
JavaScript
as
your
DSL
is
that
Java
scripts,
one
of
the
most
popular
languages
on
github.
B
If
you
look
at
the
statistics
for
all
the
repositories
that
are
up
there,
so
it's
a
language,
that's
widely
understood
and
what
breed
does
as
a
tool?
Is
it
solves
the
CI
integration
with
kubernetes?
So
as
a
developer,
you
don't
want
to
use
a
tool
like
cube
cut',
all
generally,
you
sort
of
want
get
to
be
your
source
of
truth,
so
this
enables
a
git
push
type
workflow.
Where
git
is
your
source
of
truth,
and
you
know
you
can
check
dashboards
and
make
sure
things
are
working.
B
The
way
they're
supposed
to
but
gate
gives
you
the
tools
to
create
specialized
workflows
pipelines.
Get
your
code
running
on
your
kubernetes
cluster.
Another
early
entrant
into
this
space
is
meta
particle.
It's
gone
a
little
stale
over
time,
which
we'll
look
at
in
a
little
bit,
but
this
take
the
declarative
peace
and
rather
than
give
you
a
DSL,
in
contrast
to
the
Gade,
what
this
is
giving.
B
You
is
an
SDK,
so
whatever
your
language
is
that
you're
working
in
you
know,
are
those
in
your
code
or
your
kubernetes
resource
as
a
separate
file
that
you
you
have
somewhere
in
your
repo
you're,
defining
it
directly
in
line
with
your
code.
So
the
hope
is
that
this
makes
it
easier
to
see
exactly
how
this
this
application
is
supposed
to
be
deployed.
And
then
the
meta
particle
system
reads
this:
once
you
pass
all
your
tests
and
everything
and
can
help
push
it
out
to
your
kubernetes
cluster.
So
that's
the
idea
behind
meta
particle.
B
As
noted,
it
is
a
little
stale
there's.
You
know.
When
I
checked
the
issues,
there
was
a
comment
from
August
26.
That
was
not
responded
to
do
basically
asking
what's
happening
with
meta
particle,
so
I
think
we
can.
We
can
safely
note
that
the
focus
is
elsewhere
at
the
moment
for
Brendan
Burns
and
the
team
that
sort
of
brought
this
out,
but
it
is
open
source.
B
So
if
you
think
this
is
a
great
idea,
you,
like
the
philosophy
of
an
SDK
I'm
sure
they
would
be
happy
to
have
folks
get
involved
and
continue
building
on
this.
So
what
meta
particle
does
is
it?
It
lowers
the
burden
necessary
to
learn
a
docker
file
or
Kate's
yamo
formats
lets
you
work
with
the
language
and
tooling
that
you're
already
accustomed
to
so
lowers
the
sort
of
learning
curve
required
to
get
your
resource
up
and
running
in
kubernetes.
B
Isopod
is
sort
of
something
that's
a
little
more
recently
come
on
to
the
frontier
it
it's
an
interesting
approach.
It
also
takes
a
DSL
approach.
This
is
an
example
of
what
eyespot
might
look
like
taken
from
some
of
their
Docs,
and
you
know
you
can
see
some
distinct
things
here,
number
one.
It
looks
vaguely
Python
like
that's,
because
it's
based
on
a
language
called
star
lark,
that's
the
same
language
that
basil
and
buk
the
build
systems
use
tilts
under
the
program.
We'll
look
at
in
a
little
bit
also
uses
star,
Lark,
I
believe
but
yeah.
B
The
the
the
thing
that
they're
trying
to
address
here
is
that
you're
testing
arm
needs
to
happen,
along
with
your
config
changes
and
being
able
to
do
that
in
a
procedural
or
an
imperative
way
where
you're
using
control
structures
like
if
if-else
are
all
that
stuff
is,
is
pretty
conducive
to
getting
things
up
and
running.
So
this
is
sort
of
I
think
the
base
file
of
what
your
isopod
format
would
look
like
and
I
like
to
think
of
isopod
as
solving
the
need
for
testing
your
configuration
changes
before
you
push
them
to
production.
B
So
I
think
there
was
a
bug
on
a
big
query
that
came
out
a
year
ago
due
to
config
changes.
That's
not
to
say
that
big
query
dropped
the
ball
or
anything.
It's
just
to
say
that
this
stuff
is
really
really
hard,
and
the
best
of
us,
you
know
are
can't
be
perfect
when
we
manage
these
things.
So
testing
is
very
important
and
I.
Think
the
push
towards
having
your
tests
sort
of
live
with
your
config
changes
is
relatively
important
scene.
B
This
is
just
the
idea
that,
in
application
in
kubernetes
is
often
not
just
a
single
container,
even
if
it
is
a
single
container
and
there's
no
side
cards
or
anything
there,
usually
a
lot
of
supporting
services
that
go
along
with
that
and
I
like
to
think
of
this.
If
I'm
elevator
pitching
this
to
people
as
it's
just
doctor
compose,
but
it's
more
neutral,
so
doctor
compose
is
obviously
tightly
coupled
to
warm
and
Dockers
way
of
doing
things.
B
The
container
ecosystem
with
OCI
and
Runcie
have
since
sort
of
become
a
little
more
agnostic
and
seen
Abbas
is
an
agnostic
or
a
more
neutral
version
of
docker
compose
where
you
can
collect
and
group
your
application
together,
but,
and
you
know,
push
it
to
different
locations
and
it's
it's
not
specific
to
any
one
thing.
So
you
know
something
else
comes
out
beyond
kubernetes,
where
you
want
to
run
your
application.
See.
Nab
hypothetically,
should
work
in
that
context,
which
is
pretty
cool.
B
It's
sort
of
you
get
the
immediate
advantage
of
having
a
neutral
way
to
the
fine
wrap
and
then
the
long-term
potential
advantage
of
its
sort
of
being
a
technology
that
that
lives
on
beyond.
Just
the
lifecycle
of
a
single
product
yeah
the
world
is
bigger
than
kubernetes.
If
you
happen
to
use
helm,
I
believe
the
folks
that
are
behind
home
honey
even
said
that
you
know
see,
NAB
potentially
can
be
something
that
is
backing
helm,
which
is
cool
as
well.
B
One
thing
to
note
is
that
see:
NAB
has,
you
know,
come
into
the
news
in
recent
weeks.
This
is
a
post
by
Jimmy,
szalinski
p.m.
and
I
think
engineer
from
core
OS
and
Red
Hat
talking
about
OCR
artifacts
and
some
of
the
early
work
that
they
did
2016-2017
thinking
about
how
to
store
helm
or
more
complete
applications
in
a
container
registry.
The
problem
is
that
a
container
registry
is
designed
just
for
a
container.
It's
not
designed
for
all
the
things
around
the
container.
B
Like
the
services
and
everything
and
Seanad
is
sort
of
becoming
this
thing
that
is
being
explored,
as
should
we
store
a
scene.
Ab
objects
in
our
registry
as
well.
This
is
something
they're
actively
designing
at
the
moment
and
as
Jimmy
points
out
in
this
medium
post,
you
should
absolutely
reach
out
to
the
folks
at
Red,
Hat
or
Microsoft,
or
any
of
the
other
companies
that
are
contributing
to
this
and
doing
the
early
work
on
it,
because
they
can't
read
your
mind.
B
So
if
there's
an
essential
feature
that
you
think
it's
to
be
added
to
that
spec
for
scene
AB
to
work
for
you
as
a
build
artifact
that
you
can
store
in
your
container
registry
definitely
get
in
touch
you,
you
will
be
helping
them
out,
I'm
sure
they
will
be
very
grateful
for
your
feedback
from
a
person
on
the
front
lines.
Kind
of
doing
this
stuff,
so
scene
AB
solves
the
problem
of
portability
beyond
just
kubernetes.
B
It
also
saw
also
the
problem
somewhat
of
organizing
the
the
disparate
resources
that
are
associated
with
the
service
running
in
kubernetes
and
good
organization.
As
we'll
see
in
some
of
the
other
tools
we
look
at
does
also
help
reduce
some
of
the
complexity
of
managing
your
workflow
as
a
developer,
something
that
has
come
out
a
little
more
recently
from
the
same
team.
Behind
Cena
at
Microsoft
is
OAM
I
think
it's
the
open
application
model,
if
I
remember
correctly
and
for
kubernetes.
This
is
implemented
as
a
reference
as
rudder.
B
So
I
saw
this
happen
on
Twitter
as
I
was
creating
the
slide
deck
recently.
So
I
figured
I'd,
cut
and
paste
it
in
here,
and
the
idea,
as
Harry
puts
it
here
is
developers
don't
have
to
consume
system,
calls
directly
to
write
a
program
on
Linux.
You
know
if
kubernetes
is
the
assembly
of
air.
Sorry,
if
ya
mole
is
the
Assembly
of
kubernetes,
then
they're
doing
something
very
similar
in
in
kubernetes
space.
Currently,
when
our
developers
are
writing
applications
for
kubernetes,
so
how
can
we
simplify
that?
B
What
layer
can
we
introduce
to
create
sort
of
a
user
space
and
the
response
that
om
is
giving
is
that
you
know?
Maybe
you
can
organize
your
demo
files
in
such
a
way
that
some
of
the
mo
is
ideally
suited
for
an
application
operator
to
fill
in,
so
the
person
running
the
infrastructure
will
fill
in
those
fields
and
then
other
parts
of
the
yamo
file
are
things
that
a
developer
will
fill
in
because
they
know
more
about
how
the
application
runs
on
that
level.
B
If
you
can
give
each
of
these
roles
you,
you
know
an
idealized
file,
a
more
organized
file
that
on
the
easily
pencil
in
values,
for
it
can
reduce
some
of
the
confusion
and
sort
of
ease
the
burden
of
bridging
the
dev
ops
transition.
When
your
your
your
pushing
code
to
production
so
I
think
that's
a
really
cool
idea
and
I
think
that's
something
that
a
lot
of
folks
miss
on
when
they're,
initially
just
kind
of
looking
at
things.
This
is
what
a
ADM
will
file
for.
B
Oam
rutter
looks
like
it
looks
very
similar
to
some
of
the
game,
while
we're
already
defining
a
lot
of
the
same
values.
Er
there
we're
still
defining
the
port,
and
you
know
some
additional
characteristics
like
the
image,
any
any
other
config
values
that
are
important
and
the
system
then
digests
that
and
produces
the
resulting
necessary
kubernetes
resource
at
the
end
of
the
day.
B
So
the
idea
is
that,
even
though
it's
still
yamo
it's
more
organized
and
it
becomes
your
new
sort
of
interface
for
looking
at
all
of
these
things,
you
you
are
looking
at
less
at
the
end
of
the
day,
because
dev
and
ops
are
collaborating
better.
So
in
a
way,
it's
exploiting
Conway's
law,
the
idea
that
the
communication
structure,
your
organization,
affects
how
your
programs
are
built
and
deployed.
You
know
you're
exploiting
the
facts
that
there
tends
to
be
different
concerns
between
developers
and
operations.
B
Folks,
as
much
as
DevOps
wants
to
make
things
everyone's
concerned,
you
know
you'll
I,
don't
know
that
anyone
ever
fully
gets
to
that
ideal.
We
always
pursue
the
ideal,
because
it's
a
good
thing,
but
at
the
end
of
the
day
we
are
beholding
to
separate
concerns.
So
the
idea
here
is
that
things
can
be
simplified
by
looking
at
things
through
the
lens
of
what
your
role
is,
which
is
pretty
cool,
build
packs
are
an
old
technology
if
you're
used
to
Heroku
or
Cloud
Foundry.
B
This
is
the
tech
that
they
really
invested
in,
and
these
are
just
like
really
simple,
like
you
can
see.
The
the
only
real
important
bit
here
in
this
app
that
I
think
it's
a
pious
or
not
JSON
is
the
image
that
we're
specifying,
which
is
the
build
pack
that
we
want
to
be
used
for
this
actual
piece
of
code,
baguette
built,
usually
there's
something
called
a
prop
file,
which
is
just
you're,
specifying
the
command.
That's
required
to
start
your
web
application
and
basically
you're
you're
off
to
the
races.
B
A
lot
of
things
are
sort
of
figured
out
for
you.
The
container
gets
created
automatically,
because
that's
what
that
build
pack
is
it's
it's
a
process
for
bundling
and
building
a
container,
and
it
will
then
deploy
to
communities
if
you
have
other
tooling
hooked
in
to
make
get
your
source
of
truth.
So
if
you
were
to
combine
build
packs
with
something
like
Brigade,
that
kind
of
bridges
the
gap,
you
can
have
a
really
neat
system
in
place.
B
But
one
thing
to
note
here
is
that
build
packs
they.
They
are
one
of
those
solutions
that
is
abstracting
some
things
away:
you're
losing
some
freedom
of
control,
obviously,
by
not
being
able
to
specify
a
lot
of
the
details
in
your
normal
docker
file.
You're
you're
dealing
a
lot
more
with
idioms
or
expected
values,
intelligent
defaults
and
you
can
customize
those
to
your
organization
by
creating
your
own
build
packs,
but
that
is
a
burden
on
the
system
still
so
it'sit's
a
trade-off
rather
than
a
pure
solution.
B
Tilt's
is
a
really
cool
tool.
It
solves
the
node
mom
problem
that
we
looked
at
earlier.
So
this
is
an
example
Tilt's
file
from
one
of
their
tutorial
areas,
and
you
can
see
the
important
part
here.
Is
you
know
it's
it's
written
in
star
lark,
that
same
pythonic
kind
of
language
but
they're
talking
about
how
live
updates
are
going
to
work
and
how
things
are
going
to
be
synchronized.
So
what
tilt
is
doing?
B
You
wrote
every
single
time,
they've
kind
of
figured
out
a
lot
of
the
edge
cases
and
complexities
around
that
and
giving
you
this
nice
tool
that
not
only
speeds
up
your
iterative
development,
but
it
also
makes
debugging
a
lot
easier
when
your
you,
you
want
to
see
it,
you
want
to
make
a
change,
see
if
it
fixed
something
for
the
bug
that
you're
looking
at
that's
also
part
of
this.
This
process,
so
tilt
is
reduced.
B
Bringing
back
that
I
would
say,
quick
feedback
loop
to
you
as
a
developer
that
you
usually
lose
when
you
move
to
container
technologies
cool
this
one
actually
isn't
an
external
project,
admission
controllers.
Those
of
you
who
are
familiar
with
kubernetes
I
may
know
that
this
is
sort
of
bundled
in
and
how
a
lot
of
authorization
and
stuff
happens
when
things
first
enter
the
cluster.
B
There
are
mutating
admission
controllers
that
can
actually
make
changes
to
files,
so
I
like
to
think
of
the
the
base,
admission,
control
or
limit
Ranger
as
one
of
those
things
that
can
make
changes
and
make
life
easier.
So
if
someone
doesn't
specify
a
resource
limit
for
the
application
that
they're
deploying
to
your
kubernetes
cluster
limit,
ranger
looks
at
it
and
actually
enters
a
default
value
for
you,
and
this
is
one
of
those
things
that
can
reduce
the
burden.
B
It's
one
less
field
that
a
developer
has
to
enter
into
their
yamo
and
think
about,
and
this
is
specified
at
the
cluster
level.
So,
depending
on
your
environment,
you
can
have
different
values
for
your
limit.
Ranger
that
you
know,
work
work
for
the
context
that
that
happen
is
running
in
I
like
this
a
lot
but
I.
Think
one
downside
to
this
potentially
can
be
that
it's
a
little
bit
opaque.
You
may
deploy
your
application
to
production.
B
Forget
that
a
lot
of
these
values
are
getting
mutated
or
tweaked,
as
things
are
getting
pulled
into
the
cluster
through
the
API
server,
and
it
can
seem
sort
of
magical.
So
you
definitely
want
to
think
about
how
you're
communicating
how
your
admission
controllers
work,
if
you
want
to
enable
or
disable
admission
controllers,
I
believe
they're
flags
on
the
API
server.
So
you
know
talk
to
your
cluster
admin
about
doing
that.
B
A
helm
is
sort
of
the
standard
that
I
hope
all
of
us
are
familiar
with
in
a
home
chart
is
something
that
looks
very
similar
to
a
normal
kubernetes
object.
That's
even
got
the
name
on
the
replication
controller
up
top
here.
In
this
example.
One
thing
to
know
is
that
you
know
near
the
bottom
of
this
page
braces
and
what
they're
doing
there
is
templating.
These
are
go
templates.
Go
templates,
look
very
similar
to
mustache
templates
surged
into
templates.
B
There
are
some
commands
or
procedures
you
can
sort
of
feed
in
an
addition
to
just
a
list
of
values,
as
seen
pictured
here.
I
think
you
know
there
is
some
bit
of
this
that's
unfortunate
and
that
people
do
have
to
be
familiar
with
go
templates,
specific
sort
of
flavor
of
templating
to
I
really
dig
into
this
stuff,
but
I
do
think
that
learning
curve
is
relatively
minor.
B
A
lot
of
the
tools
that
we're
going
to
look
at
in
the
next
couple
pages-
and
one
of
them
that
we
already
looked
at
previously
isopod
are
gonna,
be
critical
of
this,
and
I
don't
think
it's
a
big
knock
on
home
in
general.
It's
more
just
to
say
it's
sort
of
like
there's
a
famous
bjorn
strop
quote
about
c++,
like
the
only
reason
people
are
complaining
is
because
they
use
it.
B
Well
enough
that
it's
become
very
popular
and
well-loved
by
a
lot
of
folks.
Now
what
a
lot
of
these
tools
are
looking
to
do
is
kind
of
do
the
whole
I'm
gonna
stand
on
the
shoulders
of
giants
that
came
before
me.
I'm
gonna,
see
if
I
can
improve
this
a
little
bit.
So
we
look
at
case
on
it
and
customize.
The
context
for
those
tools
is
really
going
to
be
about
seeing
if
we
can
do
something,
that's
even
better
than
templating.
B
Templating
works
well
enough
for
some
cases,
but
when
you
get
to
complex
multi
cluster
multi
environment
scenarios,
there
can
be
some
challenges.
So
what
home
does
really
nicely?
Is
it's
part
of
what
scene
app?
Did
it
bundles
your
applications
together?
It
does
something
that
nothing
else
does,
which
is.
It
gives
your
developers
a
menu
of
options
that
you
can
really
choose
from,
and
it
also
helps
manage
sort
of
the
basic
lifecycle
of
your
application
if
your
charts
are
defined
well,
so
helm
is
a
great
basis
to
start
with.
B
If
you
have
absolutely
no
developer
friendly,
tooling
and
I
believe
home
version
3,
which
is
the
version
that
has
tiller
lifts
deployment,
uses
CR,
DS
and
other
fancy
controller
stuff
instead
on
kubernetes,
that
is
in
release
candidate
phase
right
now.
So
now,
how
is
a
great
time
to
download
that
test?
It
out
give
your
feedback
to
the
home
team
cool
case
on.
B
It
is
a
tool
that
is
based
on
something
called
JSON
it,
and
the
idea
is
that
if
you
give
people
a
basic
command-line
tool
and
some
primitive
objects
or
prototypes
or
components
as
they
call
them,
sometimes
you
can
use
those
prototypes
and
primitive
objects
to
combine
things
together
on
the
command
line
and
generate
very
quickly
the
type
of
resource
that
you
want
to
deploy.
I
think
the
obvious
criticism
of
this
is
just
that.
B
Unfortunately,
it's
it's
worth
noting
that
when
hekia
was
acquired
and
they
sort
of
took
inventory
of
what
was
happening,
you
know
how
much
excitement
or
community
interest
there
was
that
they
found
that
a
lot
of
folks
found
case
on
it
pretty
challenging.
So
they
started
to
scale
down
the
investment
in
the
projects.
It's
still
again
open
source
similar
to
met
a
part
of,
and
it's
I
think
there
are
a
lot
of
interesting
and
good
lessons
to
take
away
from
what
case
on
it
did.
B
In
particular,
brian
miles
gave
a
great
talk
at
cube
con
recently
and
I
think
this
design
criteria.
I
want
the
easy
things
to
be
easy
and
the
hard
things
to
be
possible.
I
hope
that's
something
that
everyone
who's
working
on
these
developer
focused
tools
is
keeping
in
mind.
You
know
the
hard
things
to
be
possible
is
probably
speaking
more
to
you.
B
Don't
want
to
limit
the
action
that
people
can
take,
so
build
packs
are
sort
of
maybe
discarding
that
a
little
early,
but
this
idea
that
keeping
things
simple
and
the
goal
is
to
make
things
accessible
and
approachable
is
a
great
Northstar
for
anyone
looking
to
improve
the
developer
experience
so
a
case
on
it.
Really,
I
would
say,
in
contrast
to
home,
addresses
a
lot
of
the
problems
that
people
have
with
multi
cluster
multi
environment
multiplicatively
complex
configuration
scenarios.
B
It
really
goes
to
great
lengths
to
keep
your
code
dry
and
composable,
so
you
can
kind
of
assemble
what
you
need
together
on
the
fly
that
comes
with
some
learning,
but
hey
so
where,
as
case
on
it,
you
know
a
shoes,
yeah
mall
in
in
favor
of
json
and
uses
an
entirely
different
format.
Customized
goes
the
other
direction
customized.
As
you
know,
what
like
yeah
mall
is
a
disease.
What
if
we
gave
you
another
disease
which
is
more
llamo
and
those
two
diseases
fight
each
other?
B
I
think
there
was
a
cure
way
back
in
the
day
a
one
of
the
primitive
cures
for
malaria,
as
they
would
inject
you
with
something
that
would
give
you
a
fever,
and
the
fever
would
kill
the
malaria
and
bing-bang-boom
your
body
gets
over
the
fever,
you're
good
to
go
it's.
It
sounds
primitive
when
you
first
hear
about
solving
yeah
mo
with
more
yeah
mo,
but
once
you
dive
into
it,
it's
actually
really
cool.
B
So
there's
great
talk
on
this,
the
detail
of
which
I
don't
have
time
to
emulate
fully
given
the
the
time
limits
of
this
presentation,
but
customer
deploy
your
app
with
the
mo
free
template
Bangkok's,
it's
another
great
cute
con
talk
kind
of
diving
into
how
this
works.
It
works
by
you
defining
a
basis
that
or
using
a
generator
to
generate
a
basis
for
you
to
then
overlay
or
patch
your
values.
On
top
of
so
this
looks
familiar
to
anyone.
Who's
worked
with
communities.
B
We
in
this
case,
where
we're
renaming
the
prefix
of
name
to
dev
or
prod,
based
on
which
of
these
environments
we'll
want
to
deploy
to.
So
if
we
go
back
one
step,
you
know
what
what
was
the
metadata
name,
my
nginx,
that
would
be
dev
my
nginx
and
the
dev
context
and
prod
my
nginx
in
the
prod
context.
So
I'm
customize
ends
up
being
a
lot
simpler.
B
There's,
maybe
you
know
handful
of
different
overlay
commands
that
give
you
access
to
a
whole
lot
of
options
for
customizing
it's
complex
and
you
can
overlay
multiple
times
on
a
single
base.
You
can
use
a
base
and
many
different
projects,
and,
in
this
case,
like
as
for
dev
or
as
for
production
and
customize,
has
actually
been
bundled
in
with
acute
cuddle
as
of
1.14.
So
this
is
a
tool
that
is
actually
potentially
available
to
you
today.
B
You
may
not
have
even
realized
it's
installed
on
your
system
and
could
make
life
a
lot
easier
for
managing
and
creating
kubernetes
objects.
So
this
this
tool
manages
to
stay
both
declarative,
we're
not
using
control
structures
or
DSL.
That
is
putting
us
through
like
four
loops
or
if-then
statements,
and
it
applies
very
cleanly
on
top
of
the
the
format
that
we're
already
familiar
with.
B
If
you're
like
me-
and
you
were
a
little
scared
by
solving
yeah
mole
with
more
yeah
MO
and
that
being
a
little
confusing
I
definitely
want
to
point
you
to
the
ship
project,
which
is
another
open
source
project,
that
kind
of
assists
with
customized,
and
it
can
show
you
sort
of
the
the
desired
target
of
you
know
these
these
different
based
files
getting
patched
how
these
values
are
gonna
change.
At
the
end
of
the
day,
when
multiple
overlays
sort
of
enter
the
picture,
it's
very
easy
to
lose
track
of
what
is
changing.
B
What
and
what
order
things
are
happening
in
I'm.
A
tool
like
ship
can
really
help,
simplify
that
so
I
think
with
ship
a
tool
similar
to
this.
You
get
a
very
fluid
and
nice
experience
with
customized
that
ends
up
being
really
cool,
and
it's
it's
a
lot
more
than
the
sum
of
its
parts.
The
the
yeah
Milnes
being
animated
eccentric
sort
of
fades
to
the
background
for
me
when
I'm
able
to
interact
with
it
in
this
kind
of
a
really
nice
fluid
way
so
customized
similar
to
caisson.
B
B
One
thing
I'll
note
before
we
get
to
the
ramp-up
in
summary
here
is
just
that.
The
experience
that
you
want
to
push
for
for
your
developers
kind
of
depends
on
your
context.
The
the
context
that
I
work
in
we're
trying
to
really
simplify
things
for
companies
that
are
just
onboarding
to
kubernetes,
to
begin
with,
which
means
we
want
as
minimal
burden
on
them
as
possible
to
support
their
apps
over.
B
So
we've
invested
with
build
packs
and
some
of
these
other
technologies
to
give
you
sort
of
this
get
push
workflow
and
the
system
is
its
NetApp
kubernetes
service,
but
you're
interested
in
that
you
can
check
it
out,
but
I
think
what
everyone
is
aiming
for
at
the
end
of
the
day
is
something
somewhere.
It's.
B
Gluing
them
together
and
agreeing
they
don't
think
any
one
tool
is
going
to
do
that.
So
that's
that's
point.
Six
on
our
summary
here,
but
the
other,
just
things
to
note
are
kubernetes
is
inherently
complex.
It's
our
space
shuttle
protecting
us
from
the
ravages
of
distributed
system,
space
outside
that's,
okay,
but
people
still
need
to
know
how
to
use
it.
They
not
everyone
needs
to
be
an
astronaut
trained
for
years
to
go
up
in
the
space
shuttle.
So
we
need
to
look
into
solutions
that
can
make
that
a
lot
more
approachable.
B
Some
tools
work
by
reducing
the
amount
on
a
yam.
Well,
we
have
to
work
with.
We
saw
that
with
the
mission
controller
as
we
saw
that
with
build
packs
and
others
try
and
take
you
away
from
Yemma
altogether.
They
provide
you
with
a
dsl
like
javascript
or
something
like
Python,
hopefully
a
language
that
you
already
know
and
allow
you
to
simplify
by
reducing
the
burden
of
you
having
to
learn
yet
another
system
or
get
another
tool
and
yeah.
That
is
the
presentation
for
today's
webinar.
So
thank
you
for
attending.
A
B
A
B
A
B
A
B
Yes,
some
degree
it
seems
like
most
of
Ison
by
hyper
scalars.
You
mean
the
first
party
cloud
options
and
seems
like
a
lot
of
them
are
offering
their
own
marketplace
of
solutions,
so
they're
kind
of
curating,
good,
helmet
arts,
good
operators,
good
good
charts
to
start
out
with
as
a
basis
for
your
kubernetes
cluster.
A
lot
of
them
are
integrating
monitoring
and
a
lot
of
other
details
deeply
into
their
stacks,
so
they're,
not
they're,
sort
of
taken
care
of
for
you,
some
of
the
security
and
off
authentication
and
authorization
is,
is
out
of
your
purview.
B
So
it's
one
less
thing
you
have
to
worry
about
when
you're
deploying
your
app
to
kubernetes
and
then
otherwise,
I
think.
A
lot
of
the
work
that's
happening
on
server
lists
is
actually
developer.
Orient's
or
yeah
developer
oriented
service
is
a
very
bad
name
for
a
very
cool
idea,
I
like
to
think
so
stuff,
like
native
or
I,
think
the
Microsoft
Project
is
kada.
There
may
be
other
service
projects
like
open
faz
on
that
and
it
get
integrated
in
the
future.
B
But
you
know
each
cloud
seems
to
be
investing
in
a
space
that
simplifies
the
things
I
think
AWS
their
play
is
with
Fargate,
where
the
the
basic
unit
that
you
think
of
is
the
container.
Not
the
server
will
see
where
they
take.
That
I
think
there's
still
a
little
bit
a
little
bit
in
development
compared
to
Microsoft
and
Google,
but
yeah
I
think
the
what
they
end
up.
Layering
on
top
of
those
service
options,
is
going
to
be
a
big
part
of
how
they
address
developer
productivity.
B
B
Iterate
on
containers
that
you're
working
with
I
would
argue
that
meta
particle
as
a
side
effect
achieves
some
of
that
same
process
of
providing
you
a
faster
feedback
loop
but
yeah,
there's
I
would
say
a
lot
of
that
is
scattered
or
optional,
or
you
know
in
the
case
of
scaffold,
it
works
with
any
cloud.
It's
not
just
Google
clouds.
So
it's!
It's
still
being
figured
out.
B
Yeah
I
mean
so
I
think,
there's
two
questions
here.
One
is:
can
you
make
it
easier
to
read
and
more
terse
and
I
think
another
pythonic
attribute
is
there's
really
one
sort
of
blessed
way
to
approach
a
problem
when
it's
usually
like
a
best
practice
or
the
standard
way.
I
think
that
standard
way
of
addressing
things
is
still
getting
figured
out.
B
B
Would
I
use?
I
I
think
how
is
a
great
starting
place
if
you're
just
getting
started
with
kubernetes,
and
you
don't
want
too
much
of
this
stuff
to
get
messy.
You
can
start
with
helm
on
helm,
includes
templates,
which
is
sort
of
the
bare
minimum
you
want
to
have
in
order
to
create
flexible
and
easy
deployments
home
also
helps
organize
things
in
a
way
that,
like
your
logical
application,
is
kind
of
bundled
together
and
in
a
set
of
files.
B
So
you
know
with
helm
you
don't
really
have
to
worry
about
seen
a
bore,
om
or
rudder
or
any
of
the
other
solutions
like
case
on
it
or
customized
like
helm,
does
a
lot
out
of
the
box,
but
it
doesn't
do
any
everything
it
can
benefit
from
being,
combined
with
tools
that
reduce
the
hot.
The
hot
reload
loop,
give
you
more
feedback
faster
as
a
developer,
so
start
with
home,
and
then
it's
they
branch
out
from
there
after
you
get
some
comfort.
A
B
Customize,
all
of
them
actually
have
specific
sections
that
call
out.
You
know
bundling
in
secrets,
I'm
sure
some
of
the
other
tools
that
I
covered
today
have
have
some
information
on
that,
but
they
they
all
have
their
own
unique
approach
to
how
to
safely
pull
in
secrets
to
your
your
value,
your
file
of
that
contains
values.
There's
one
project,
I
believe
by
bit.
B
Nami
it
escapes
me
it's
maybe
bit
Nami
or
Go
Daddy
I
can't
remember
which,
but
it
it's
a
way
to
encode
a
secret
and
in
a
hash
that
is
Noble
only
to
your
secret
store
on
your
kubernetes
cluster
requires
some
tooling
to
be
there
as
well,
but
you
can
safely
commit
it
to
your
git
repo
and
not
worry
about
someone
just
deploying
that
to
your
cluster
and
having
it
work
as
well.
It's
it's!
It
relies
on
some
other
third
secret
information.
A
B
Yeah
I
think
tools
like
that
are
great
they're,
really
useful
for
debugging
when
you're
live
debugging,
but
I
would
say
they
are
antithetical
or
counter
to
some
of
the
goals
of
kubernetes.
Part
of
what
kubernetes
and
containers
are
about
is
immutable
infrastructure,
and
you
know
part
of
in
parts
of
this
presentation.
We
talked
about
git,
being
your
source
of
truth
when
you're
applying
a
patch
using
cube
cuddle
or
your
you're
modifying
things
live
that
are
in
production
and
deploying
that
way
you
lose
that
that
get
as
the
source
of
truth.
B
B
Tamil
is
an
alternative
to
llamo
I
mean
I
like
Tamil.
It
reads
a
little
more
cleanly
to
me
and
I:
don't
have
to
deal
with
a
lot
of
the
spacing
ugliness
but
I
think
it
it
fumbles
in
a
lot
of
the
same
areas
as
UML.
At
the
end
of
the
day,
when
you
get
a
lot
of
data
in
Tamil,
it
can
be
as
burdensome
in
some
areas
as
yam.
Oh
it's
great.
If
you
can
make
Tamil
your
your
markup
language
of
choice,
I
think,
there's
some
go
tools
by
forget
his
name.
B
There's
some
tools
from
him.
I
think
called
Viper
that
is
used
in
Hugo,
for
you
can
use
any
configuration
language
you
want
and
Viper
will
translate
it
that
that
stuff,
I
think
is
really
neat,
but
at
the
end
of
the
day
it's
still
a
markup
language
and
it's
still
an
awkward
fit
and
there's
you're
still
mapping
to
kubernetes
resources
and
docker
files.
So
it's
an
improvement,
but
it's
it's
one.
Minor
improvement
on
the
road
to
the
ultimate
goal
of
reducing
complexity
for
developers.
A
Okay,
I'm
gonna
have
to
end
things
now,
I'm
great
thanks
for
a
great
presentation.
That's
all
the
time
we
have
for
questions
thanks.
Everyone
for
joining
us
today
and
though
ever
in
our
recordings
and
slides,
will
be
online
later
today,
we're
looking
forward
to
seeing
you
at
a
future
CN
CF
webinar
have
a
great
day
Thanks.