►
From YouTube: TGI Kubernetes 079: YTT and Kapp
Description
Episode notes: https://github.com/heptio/tgik/tree/master/episodes/079
00:00:00 - Welcome to TGIK!
00:04:30 - Week in Review
00:21:11 - Start looking at k14s
00:28:49 - Install the tools
00:36:07 - Start playing with kapp
01:02:52 - Start playing with ytt
Come hang out with Joe Beda as he does a bit of hands on hacking of Kubernetes and related topics. Some of this will be Joe talking about the things he knows. Some of this will be Joe exploring something new with the audience. Come join the fun, ask questions, comment, and participate in the live chat!
This week we will look at YTT and Kapp! These tools are used for templating and applying configs to container clusters and take a bit of a unique approach.
A
All
right
welcome,
welcome,
welcome
everybody
to
another
episode
of
teach
kubernetes.
It
is
Friday
1:00
p.m.
here
in
I'm,
not
in
Seattle
anymore
I'm,
actually
in
Bellevue
and
yeah
on
the
west
coast
of
the
US,
and
we're
going
to
be
talking
some
kubernetes
I'm
actually
in
my
new
office
here,
I'll
give
you
a
little
bit
of
a
tour
but
first
of
all
some
hellos
to
some
folks
on
the
line.
So
we
have
Martin
from
the
Netherlands
LeMat
e
good
to
see
you.
A
A
It
was
very
tongue-in-cheek.
Nima
Allen
from
Scotland
I've
been
good
to
see.
Y'all,
alright,
so
I've
moved
offices,
so
heftier
was
in
seattle
and
now
we've
moved.
Oh
yeah
I've
been
from
Colombia
good
to
see
ya
live
on
Avon,
maybe
there's
a
there's
a
yeah,
so
I
move
off
as
we
were
in
Seattle,
which
is
closer
to
the
to
the
ocean
to
the
Puget
Sound
I'm.
Now
in
Bellevue,
which
is
like
kind
of
a
suburb,
that's
a
across
Lake
Washington!
That's
where
the
vmware
offices
are.
A
We
no
longer
have
independent
FTO
offices,
it's
kind
of
a
little
bit
sad,
but
it's
also,
you
know
the
the
the
price
of
progress,
but
I
do
have
a
view,
so
you
can
check
out
my
cool
view.
So
we
have
like
you
know
we
got
buildings
and
stuff,
and
so
you
know
it's
it's
kind
of
cool,
but
because
I
have
the
window.
I
have
a
little
bit
more
road
noise
and
stuff.
A
The
the
the
studio
that
we'd
set
up
in
Seattle
was
a
little
bit
of
a
closet,
so
frederico
good
to
see
you
from
Gutenberg
Timmy
good
to
see
you
also
all
right
well
welcome.
Welcome!
Welcome
everybody.
I'm
really
excited
to
be
doing
TGI,
K
again
I'm
going
to
be
doing
more
of
these
trying
to
trying
to
defend
my
schedule
and
keep
the
time
because
I
really
really
enjoy
it.
A
And
let's
see
let
me
just
here
and
so
for
those
who
don't
know
I'll
give
a
little
intro
here.
Tgi
K
is
a
weekly
livestream
that
I
do.
Where
review
some,
you
know
some
of
the
stuff
that's
happening
across
the
kubernetes
ecosystem
in
the
cloud
data
ecosystem
and
then
and
then
do
a
deep
dive
on
a
technology
oftentimes.
It's
a
technology
that
I
don't
have
a
lot
of
personal
experience
with,
and
so
it's
kind
of
fun
to
explore
these
things
together
and
see
what
we
can
do.
A
One
of
the
things
yeah
that
I
did
want
to
note
is
that
we
have
a
new
channel
part
of
sort
of
integrating
hep
tio
into
VMware.
Is
that
we
have
transitioned
the
hep
to
your
channel
to
the
VMware
cloud
native
applications
channel.
It
just
rolls
off
the
tongue.
Doesn't
it,
but
just
trying
to
like
collect
a
lot
of
this
sort
of
you
know
stuff
that
we're
doing
including
TGI
K,
including
a
bunch
of
other
stuff
across
the
way.
A
So
that's
a
lot
of
fun
doing
that
and
yeah,
and
so
the
topic
that
we're
going
to
be
covering
today
is
this
tool
set
for
wrangling
amyl.
So
yet
another
sort
of
configuration
template
tool
set.
This
one
is
really
really
interesting.
I
did
a
TG
a
TGI
K
live
at
cube
con
in
Barcelona
on
this,
where
we
explored
it.
A
A
lot
to
like
that
I'm
really
interested
in
getting
into
the
tool
set
itself
is,
is
K
14
X,
which
is
kubernetes
tools,
but
the
ones
that
we're
gonna
be
looking
at,
or
at
least
I'm
going
to
be
digging
into
today.
Is
why
TT
and
K
app,
but
we'll
get
to
that,
but
first
of
all
sort
of
some
notes
here.
So
the
first
thing,
let
me
switch
to
my
screen.
So
the
first
thing
that
I
want
to
talk
about
is
that
we
have
a
a
hack
MD,
that
you
can
all
start
putting
some
notes
into.
A
So
if
there's
something
interesting
or
or
if
somebody
wants
to
say
hey,
you
know
this
is
the
time
when
Joe
started
talking
about
X,
there's
a
good
place
to
put
that
and
yeah,
and
so
here's
all
the
stuff
that
I'm
going
to
be
going
over
here,
real
quick.
So
the
first
thing
is
the
image
for
this
particular
episode
was
was
here.
This
is
the
element
atrium
I.
A
You
know
and
I'd
like
to
say
that
I
knew
how
to
pronounce
each
reom,
but
I
actually
had
to
ask
Google
how
to
pronounce
it,
and
it
actually
told
me,
but
it's
a
it's.
It's
an
element
that
starts
with
Y
TT
and
so
I
knew
that
this
was
an
element.
I
know
nothing
about
it,
but
when
I
saw
the
name
of
the
project
Y
TT,
which
I
think
is
you
know,
yeah
mo
templating,
something
or
another,
then
I
immediately
thought
of
this,
and
so
so
that
was
kind
of
fun.
A
And
so
you
know
we'll
learn
a
little
science
here
together
kind
of
cool,
it's
a
really
cool.
Looking
crystal
though,
and
then
yeah.
So
that's
the
first
thing
now
the
next
thing
is
is
George
is
not
going
to
be
manning.
The
chat
today,
because
he's
he's
actually
doing
a
lot
of
work,
getting
ready
for
the
kubernetes
1.16
release.
His
job
is
to
pull
together
a
lot
of
the
lot
of
the
release,
notes
in
the
blog
post
and
so
he's
helping
out
there.
A
But
I
asked
him
em
like
hey.
What
are
the
big
things
coming
in
1:16?
He
put
together
a
really
quick
summary.
For
me.
First
thing
is
a
lot
of
the
work
going
in.
Is
there
on
extensibility
via
API
machinery,
most
of
the
feature
keps
this
time
around
were
around
that
stability
production
features
in
cube
admin
things
like
H
I.
That
type
of
thing
really
interesting
to
see
us
continue
to
to
drive
forward
with,
say,
cluster
lifecycle.
A
A
A
A
Let's
see,
did
aetherium
get
its
name
from
the
elements
as
well.
I,
don't
know
I
mean,
but
you
know
it's
not
uncommon.
You
know
whatever
you're
searching
for
names
of
like
open-source
projects,
it's
almost
impossible
to
find
a
name.
That's
interesting
and
hasn't
already
been
taken.
So
it's
not
uncommon
to
see.
Folks,
like
you
know,
borrow
element
names
for
this.
I
know
that
that
there's
a
there
was
a
virtualization
project
that
we
were
doing
at
Google
called
a
B'nai
diem
back
in
the
day.
A
A
Google
and
I
got
an
email,
because
I
have
a
gke
cluster
that
I
launched
is
is,
is
moving
away
from
their
Service
Catalog
interface,
they're
they're,
actually
deprecating
that
and
they're
moving.
Everything
to
this
thing
called
the
GCP
config.
Wait!
No!
Is
this
the
thing
that
I
was
thinking
about?
No,
this
was
not
the
thing
I
was
thinking
about,
should
what
did
I?
Where
did
I
get
this
link?
I,
don't
even
know
what
link
this
is.
A
This
is
a
thing
that
I
hadn't,
seen
before
wow
I
am
like
not
config'
connector,
so
we're
gonna
find
the
right
link,
GCP
service,
catalog
right
so
anyway,
so
the
service
catalog
was
a
is
a
way
to
essentially
yeah.
So
this
is
the
GCP,
so
the
service
broker
I'm
sorry,
the
service
broker
was
essentially
a
sort
of
super
generic
way
to
get
access
to
services,
but
I
think
what
we're
seeing
is
folks
are
moving
towards
something
that
is
a
little
bit
more
I
didn't
think
this
was
the
one
that
we
were
talking
about.
A
Let
me
give
me
three
seconds
here,
because
I'm
trying
to
find
us
I
had
a
link
to
the
thing
that
I
was
thinking
about,
and
this
isn't
it,
but
the
Service
Catalog
then,
is
a
very
narrow
sort
of
like
API,
it's
friendly
for
non
kubernetes
systems,
because
it's
a
relatively
simple
API,
but
we're
you
know
we're
finding
a
lot.
A
lot
of
folks
are
moving
towards
things
that
are
more
kubernetes
native,
so
that,
instead
of
having
say
hey,
you
know
a
very
narrow
API
that
says,
give
me
a
my
sequel
database.
A
People
are
moving
towards
representing
these
things
as
CRTs
with
having
controllers
which
lets
you
have
a
lot
more
richness
with
how
you
actually
specify
configuring
and
managing
external
services-
and
we
saw
Amazon-
do
something
similar
where,
like
hey,
if
you
want
to
create
an
RDS
instance,
create
a
CR
deed
that
then
goes
ahead
and
calls
causes
that
RDS
instant
to
be
created.
I
guess
this
is
the
one
the
config
connector
is
the
one
that
I
was
thinking
about,
but
yeah.
So
this
is
there's
not
a
lot
in
this
repo.
A
That's
the
thing
that
confuses
me
a
little
bit
I
think.
Maybe
it's
all
closed
source,
perhaps
all
right
so
but
anyways
I
think
it's
really
interesting
to
sort
of
see
how
some
ideas
are
tried
out
using
the
extensibility
mechanisms
in
kubernetes,
but
over
time,
folks
figure
out
what
works,
what
doesn't
work
and
and
we'll
see
evolution
of
things
from
like
using
a
Service
Catalog
to
to
something?
That's
much
more
kubernetes
native,
which
is,
is
really
interesting.
Alright,
so
next
topic,
Tai,
Guerra
and
calico-
is
starting
to
actually
adopt
EBP
F.
So
this
is
really
interesting.
A
I
am
NOT
an
e
BB
F
EB
PF
expert.
It's
one
of
those
things
where
Tom
my
list,
where
I'd
really
love
to
be
able
to
actually
dig
into
it
at
some
point,
but
essentially
what
it
is
is
it's
a
programming
language
that
can
get
compiled
down
into
a
relatively
generic
machine
thing
and
and
get
installed
into
the
kernel
and
run
in
the
kernel.
A
So
it's
stands
for
Berkeley
packet
filters,
but
to
some
degree
this
feels
a
little
bit
like
sort
of
you
know:
pixel
shaders,
for
the
network.
Right
where
you
have
this
look-
and
this
is
my
impression-
I-
haven't
done
a
lot
with
it,
but
it's
this
idea
that
you
have
it
like
sort
of
a
specialized
language.
You
can
compile
that
down.
I,
don't
think.
A
There's
a
specialized
language,
necessary
I
think
you
can
actually
use
a
bunch
of
languages
and
then
it
gets
run
in
a
sandbox
mode
inside
of
the
kernel
for
being
able
to
do
stuff,
and
so
this
you
know
essentially,
is
a
way
to
extend
what
you're
doing
with
networking
stuff
without
creating
more
and
more
complex
systems
like
IP
tables,
kind
of
cool
kind
of
cool
stuff.
All
right,
let's
see
more
notes
on
the
the
certified
kubernetes
administrator
certification
now
valid
for
three
years.
A
A
Let's
see
Bogdan
from
Romania
good
to
see
you
and
Christoph,
you
found
us
awesome
all
right
and
then
one
of
the
things
I
wanted
to
talk
about
here,
and
so
this
is
the
first
time
I've
done
a
TGI
caissons,
cube
Khan
and
one
of
the
you
know
interesting
announcements
out
of
cube.
Khan
was
this
thing
called
SMI
and
I.
A
Can
we
apply
those
to
service
mesh
still
very,
very
early?
The
interesting
thing
for
me
is:
is
it's
actually
broken
out
across
three
different
types
of
things
that
you
can
implement
and
and
and
when
I
first
started
looking
at
sto
if
service
meshes,
my
approach
was
like
hey,
there's
three
reasons
why
folks
are
interested
in
service
meshes?
One
of
these
is
sort
of
security
and
policy
being
able
to
encryption
between
everything,
maybe
have
some
sort
of
generic.
You
know
centrally
deployed
access
management
between
services.
That
type
of
thing,
a
big
thing
is
telemetry
and
observability.
A
What's
happening
with
my
services,
that's
one
of
the
other
huge
features
out
of
a
service
mesh
and
the
other
one
is
sort
of
traffic,
routing
and
management
being
able
to
do
blue/green
redirect
that
type
of
thing.
The
interesting
thing
for
me
that
I
really
like
about
SMI
is:
it
actually
starts
to
decouple
those
different
features
right
so
like
if
I
just
want
traffic
management,
there's
a
spec
for
that
that
can
be
separated
from
the
encryption
I'm
still
very,
very
early
days
for
this,
but
I
think
well.
A
A
A
And
if
you
look
at
the
title
here,
it's
called
what
the
duck
I
think
veal,
a
really
wanted
to
call
it
this
I'm
guessing
and
they
probably
had
to
tone
it
down.
But
the
idea
here
is
that
we
can
take
a
certain
amount
of
duck
typing
and
apply
to
kubernetes
resources.
And
so
here
we
have
duck
typing.
Where
is
that
if
a
part
of
the
yamo
fits
a
certain
type
of
schema,
you
can
operate
against
that
without
actually
knowing
the
rest
of
the
animal.
A
And
so,
if
you
have
this
idea
of
like
well,
this
resource
has
a
pod
template
right,
but
it
could
be
a
replica
set.
It
could
be
a
deployment.
It
could
be
a
you
know,
a
cron
job.
Those
are
all
things
that
actually
somewhere
in
there
actually
have
something
that
is
the
pod
template.
Well,
we
can
now
operate
against
that
image.
Generic
manner
using
sort
of
duck
typing
ideas
here
duck
typing,
is
that
if
it
looks
like
a
duck
and
quacks
like
a
duck,
then
treat
it
like
a
duck.
A
That's
kind
of
the
idea
behind
duck
typing,
and
then
they
further
extended
this
by
taking
some
other
patterns
that
are
really
useful,
like
hey,
every
status
should
have
an
array
of
conditions.
We
do
have
that
in
a
couple
places
in
the
kubernetes
api,
but
the
idea
with
this
is
that
we
can
really
sort
of
make
that
be
a
regular
thing,
so
that
conditions
are
everywhere
and
universally.
Like
you
know,
a
condition
being
true
is
a
bad
thing.
A
So
if
you
see
something
with
true,
you
show
red,
you
show
a
warning,
whereas
condition
being
false,
so
like
making
sure
that
the
sense
of
that
condition
is
uniform
and
then
having
something
like,
like
you
know,
configured
or
completed
I'm,
trying
to
remember
the
you
know,
a
standard
condition.
That
means
that
hey
this
thing
has
come
charged,
so
some
really
interesting
ideas
coming
out
of
out
of
a
lot
of
the
work
in
K
native,
and
it's
going
to
be
interesting
to
see
if
we
can
apply
those
to
other
places
in
the
in
the
kubernetes
ecosystem.
A
And
so
this
is
the
the
presentation
and
there's
the
video
here
yeah
and
there's
VA
and
there's
Matt.
You
know
you
obviously
they're
playing
with
the
the
duck
typing
thing:
a
lot.
Okay,
so
so
well,
it
is
like
what
do
I
think
about
Solomon's
hiked
week.
If
it
wasn't,
was
the
exist
in
2008,
we
wouldn't
have
needed
to
create
a
docker.
That's
how
important
it
is
web
assembly
on
the
server
is
the
future
of
computing
I.
Think
that's
hyperbole,
I
think
right
now.
This
is
very
similar
to
you
know.
A
A
Stock
sort
of
Linux
distribution,
you
could
take
those
install
instructions,
put
those
in
a
docker
file
and
actually
make
them
successful
and
actually
get
something
up
and
running.
That's
very,
very,
very
different
than
then
saying
hey.
I
have
a
new
compile
target,
a
new
architecture
that
I
can
talk
to.
There
was
you
know
we
have
technologies
like
gee
visor.
We
have
yuna
kernels.
We
have,
oh
god,
I'm,
trying
to
remember.
A
There
was
the
sort
of
the
the
x86
assembly
analysis
that
got
built
into
browsers,
also,
which
was
a
similar
type
of
system.
How
can
we
take
x86
sanitize?
It
know
that
it's
safe
to
run
and
then
go
ahead
and
run
it.
That's
essentially
sort
of
hits
the
same
level
as
web
assembly.
I
think
those
things
are
all
great,
but
it's
not
a
replacement
of
actually
having
a
sort
of
standard
tool
chain.
A
A
Alright,
so
I
want
to
start
talking
about
about
kubernetes
tools,
k
14s.
This
is
a
blonde
wait.
There's
a
blog
post
here
that
I
do
do
where
to
go
where
to
go
the
blog
post,
oh
yeah,
and
then
there's
another
blog
post
that
goes
into
ytt
directly,
but
this
blog
post.
This
is
the
one
that
I'm
actually
going
to
go
work
through
a
little
bit
and
I
started
looking
at
it,
but
I
actually
haven't
had
a
chance
to
go
through
this
yet
so
this
should
be
fun.
A
That
would
sort
of
tweak
your
y
ammo
and
then
you
could
go
ahead
and
do
an
apply
and
and
I
think
you
know
at
the
time
we
didn't
have
enough
experience
to
really
do
the
right
thing
here.
The
API
patterns
we're
still
in
flux
and
so
still
very,
very
early
on
when
that
was
happening.
I
also
think
that
he
created
sort
of
tools
that
were
probably
too
small
to
targeted,
so
he
would
have
like
a
tool
that
said
like.
Let
me
rewrite
the
you
know.
A
Add
a
label
to
everything
would
be
a
very
separate
binary,
and
so
it
started
looking
especially
with
with
go
being
static.
Binaries
that
started
looking
like
this
tool
change
would
be
absolutely
ginormous,
but
I
think
the
same
idea.
The
same
spirit
is
actually
care
through
with
the
K
14s
tools
here,
in
that
they
are
here's
like
the
other
pager.
In
that
it's
it's
it's.
A
The
idea
that
you
can,
you
know
essentially
take
yamo
and
actually
sort
of
do
a
pipeline
of
processing
and
then
get
to
the
point
where
you
apply
it,
which
is
a
really
really
interesting
idea.
It's
applying
sort
of
like
UNIX
philosophy
to
to
you,
know
the
kubernetes.
You
know
configuration
tool
chain,
super
cool,
stuff,
I'm,
really
really
interested
in
digging
into
it,
and
so
the
tools
that
we're
going
to
be
looking
at
specifically
here
and
there's,
there's
four
of
them
here
and
I'm
still
exploring
all
of
these
things.
A
I
haven't
had
as
much
time
as
I'd
like
to
really
dig
into
it,
but
we're
going
to
be
exploring
ytt,
which
is
essentially
a
yeah
mole
templating
engine,
and
if
we
go
ahead
and
click
through
here,
you
know
we,
as
in
like
a
lot
of
the
folks
watching
here,
closely
associate
yamo
with
kubernetes,
but
you
know
it
has
a
long
and
illustrious
history
you
know
outside
of
kubernetes,
and
it's
used
in
a
bunch
of
different
places
and
so
Dimitri
who's.
One
of
the
authors
he's
joining
us
here
works
for
pivotal.
A
One
of
the
sort
of
foundational
technologies
that
pivotal
is
heavily
invested
in
is
is
Bosch,
which
also
uses
Hamel
and
so
I
think.
Perhaps
this
idea
that,
like
templating
ml,
is
a
useful
thing
in
a
context
that
goes
beyond.
Kubernetes
is
a
really
interesting
thing
here.
I
also
think
that
it's
interesting
that
this
is
in
some
ways
comparable
to
JSON
it,
which
I
think
you
know
we've
done.
You
know
I've
talked
about
in
the
past,
but
is
much
more
feels
like
an
annotation
extension
of
VMO
versus
a
rethink
of
something
like
that
altogether.
A
A
The
I
think
there's
also
opportunities
to
perhaps
and
I,
don't
know
if
it
does
this
to
actually
paper
over
some
of
the
and
fix
some
of
the
the
common
gotchas
for
things
like
Gamal.
So
it
might
be.
You
know
and
I'm.
You
can
tell
me
Dmitry
because,
like
one
of
the
things-
and
this
is
a
famous
sort
of
thing-
is
that
people
end
up
in
the
past
of
had
Yama
where
they
actually
have
country
code,
and
then
you
were
like
US
UK.
A
A
So
Dimitri
is
saying
that
that
they,
you
know
Neiman
him
briefly
discussed
how
far
to
go
in
terms
of
limiting
me,
ammo
gotchas
at
the
parsing
stage,
but
haven't
decided
to
do
so
to
maintain
compatibilities
I.
Think
that's
a
good
thing,
but
I
think
like
having
a
warning
or
a
lint
or
a
you
know.
Turn
warnings
into
errors.
A
Type
of
thing
might
be
a
good
way
to
approach
this,
because
you
know
the
animals
great
until
it's
not
so
we're
going
to
explore
ytt
and
then
the
other
one
we're
going
to
explore
is
K
app
duo,
announcing
K
upper
cap
I'm
wondering
but
K
app
is,
is
a
kubernetes
supplier.
It's
essentially
okay,
so
you
pronounce
a
cap
okay,
so
it's
just
it's
essentially
a
a
better
version
of
cube
control,
apply
and
there's
a
whole
bunch
of
features
here.
That
I
find
super
super
interesting
that
really
go
beyond
cube.
A
Control
apply
the
big
one
is
that
you
can
actually
do
a
diff
versus
a
plot,
and
you
know
versus
an
apply.
You
could
say:
hey
I
want
to
play
the
GM.
Oh
look
at
the
mo
look.
Look!
What's
in
the
cluster!
Tell
me
what
you're
about
to
do
before
you.
Do
it?
That's
not
something
that
we
actually
have
in
in
Cube
control
apply
and-
and
it
starts
to
feel
a
little
bit
like
when
you
use
terraform.
A
As
you
start
doing
this,
but
there's
a
bunch
of
other
really
interesting
things
here,
like
you
can
actually
with
cap,
you
can
say
only
install
into
this
particular
namespace,
and
so
you
know
anybody
who's
watched
a
lot
of
TGI
Cades
will
know
that
anytime,
before
I
install
a
system
I
do
an
exhaustive
search
through
the
yam.
Well,
that's
about
to
be
applied
so
that
I
know
what
it's
doing
cap,
because
it
can
actually
help
you
understand.
A
All
this
stuff
is
a
way
that
you
can
go
ahead
and
start
putting
constraints
at
the
tooling
level
at
a
place
that
you
trust
before
you
actually
go
ahead
and
get
to
the
get
to
the
actual
yam,
and
so
that's
really
really
interesting,
and
then
Bogdan
says
that
coming
from
a
JavaScript
typescript
background,
I
still
think
that
bloomie
is
the
best
approach
of
kubernetes
infrastructure
as
code
yeah,
yeah
I.
Think
paluma
is
super
interesting,
also
and
I.
Think
the
power
of
paluma
is
that
it
actually
goes
beyond
just
kubernetes.
A
A
Add
complexity
as
you
need
those
features
as
you
need
that
complexity
is
a
really
important
aspect
of
anything.
That's
actually
operating
at
this
layer
of
our
stack.
All
right,
so
I've
been
talking
a
lot.
Let's
actually
do
some
stuff,
let's
see
so
what
we're
going
to
do
is
we
have
a
simple
application
here:
I'm
gonna
go
ahead
and
clone
this
and
we'll
see
what
we
have
going
on
here.
Cde
goes,
I,
haven't
done
this
yet
so
Oh
first,
we
gotta
install
the
darn
thing.
I
think
I
had
it
installed
before.
A
A
A
Yeah,
so
here
there
we
go,
we
have
app.
We
have
a
docker
file.
Oh
man,
I
haven't
pushed
a
docker
file
and
forever.
So
it's
me
interesting
and
then
we
have
a
readme
on
how
to
do
this.
All
right.
Let's
see,
I
assume
that
y'all,
let's
see
if
we
look
at
minimal
there's
a
a
container
here-
that's
already
there.
Okay,
so
I'm
gonna
use
that
one
will
skip
actually
building
that.
A
A
Okay,
so
suggestion
to
me
to
you:
Dimitri,
it's
like
with
packet
managers,
I
know
with
a
lot
of
them.
You
can
create
sort
of
like
a
route
package
that
then
installs
a
bunch
of
soft
packages.
It
might
be
interesting
just
to
have
a
sort
of
k14
s
package
that
like
gets
all
of
these
and
that
way,
if
you
add
more
tools
into
this
tool
chain
over
time,
you
can
actually
you
know
people
just
get
it
for
free.
A
A
Yes,
and
the
reason
why
I'm
going
to
tell
you
this
is
that
Pulu
me
does
a
little
bit
of
abstracting
sort
of
the
the
kubernetes
schemas
and
yamo,
but
at
the
end
of
the
day
you
still
have
to
learn
that
stuff
and
so
so
to
be
effective
with
Pulu
me
and
kubernetes.
You
both
have
to
understand
the
kubernetes
api
and
you
have
to
understand
how
to
actually
generate
that
using
a
program.
A
At
some
point
we
may
get
to
the
point
where
we
can
actually
create
high-level,
simpler
abstractions,
but
those
things
come
in
a
cost
also
because
you
know,
there's
always
gonna,
be
that
one
parameter
that
you
want
to
tweak
that
you
can't
tweak,
and
now
you
have
to
plumb
that
through
and
that
breaks
the
abstraction.
So
it's
a
really
hard
problem
of
can
I
make
something
that
has
a
lot
of
knobs.
Has
a
lot
of
necessary
complexity?
A
So,
let's
see
so
the
nice
thing
was
believe
me,
I,
think,
is
that
you
can
just
start
with
the
animals
and
slowly
transition.
I
know
that
they're
getting
better
at
that
I
know.
I've
talked
to
Joe
and
the
team
over
there,
and
they
are
thinking
about
that
journey
from
starting
with
the
animal.
But
there
still
is
a
certain
amount
of
at
least
last
I
looked
at
where
you
have
to
pick
a
programming
language.
You
have
to
sort
of
create
some
scaffolding
around
it.
That
may
be
intimidating
all
right.
A
So
I
had
a
little
bit
of
a
scram
before
we
started
t
gik,
because
I
I
went
ahead
and
I
actually
have
my
laptop
hardwired
into
the
network
here
and
they
actually
locked
that
down,
so
I
wasn't
able
to
do
YouTube
streaming
and
so
I
had
to
join
our
guest
network
here.
To
do
this,
and
so
I'm
not
actually
on
a
hard
wired
network
here
right
now,
so
hopefully
we
don't
hit
any
hiccups
and-
and
things
are
gonna,
be
gonna
be
fast
enough.
Okay,
so
we
got
the
tool
set.
Now
we
can
type
ytt.
A
A
Okay,
abdun
ors
says
coming
late,
but
quick
question
does
k14
s
equals
k,
8s
+,
kick
no
no
k.
14
S
stands
for
kubernetes
tools,
so
that's
the
K
in
the
ass
and
I
guess:
there's
Fork,
I
didn't
count
them
I!
Guess
there's
14
letters
in
between.
Does
it
count
the
space
I?
Don't
know,
we
can
actually
see
kubernetes
tools,
I'm
gonna
count
here.
Alright,
we
have
one
two,
three,
four,
five,
six,
seven,
eight
nine
ten,
eleven
twelve
thirteen
fourteen.
So
yes,
it
does
count
the
space,
otherwise
BK,
13s
and
that'd
be
unlucky.
A
So
the
nice
thing-
and
you
can
already
see
that
this
is
actually
nicer
than
cube
control
apply-
is
that
it
actually
tells
me
what's
about
to
happen,
which
is
really
cool.
It's
like
hey,
I'm
gonna,
create
a
deployment
in
a
service.
These
are
in
the
same
namespace
I
assume
that
the
tilde
here
means
that
it's
actually
the
same
as
the
one
above
it,
and
these
are
going
to
be
added,
and
so
you
know
added
deleted
whatever
it's
like.
It
actually
figures
that
out,
which
I
think
is
super
super
super
cool.
A
This
is
problematic,
I
mean
I,
think
you
know
my
guess
and
I
bet
you.
If
we
cracked
open
the
source
code
for
cap,
we
would
actually
find
that
there
special
casing
over,
like
okay,
when
you're
doing
a
deployment.
That
means
that
you
have
to
wait
until
you
know
you
have
the
right
number
of
pods
that
type
of
thing
they
probably
have
to
have
a
lot
of
special
casing
for
for
for
this
particular
kubernetes
resource.
A
This
is
what
it
means
for
it
to
actually
be
converged
and
I'm
going
to
wait
until
that
happens,
that
kind
of
sucks-
and
so
this
actually
then
brings
us
back
to
some
of
them.
The
patterns
that
the
K
NATO
folks
were
doing,
whereas
it
would
be
great
if
we
actually
had
a
standard
set
of
conditions
where
completed
already
was
a
standard
condition
and
and
then
there
wouldn't
have
to
be
special
case
code
in
tooling
like
this,
and
so
this
is
actually
I.
A
Think
a
bug,
slash,
missed
opportunity
in
the
kubernetes
schemas
to
be
able
to
do
this,
and
you
know
maybe
we'll
go
ahead
and
fix
this
at
some
point.
But
it's
it's
one
of
those
like
it's.
It's
gonna
be
a
lot
of
work,
but
it
would
be
very
cool
if
we
could
do
it
so
Demetri
says
currently
we
special
case
a
few
things,
but
want
to
add
some
generic
rules
that
authors
can
add
themselves
as
annotations
and
yet
definitely
be
graded
yeah.
A
So
this
would
be
super
super
cool
to
see
more
patterns,
more
schemas
that
actually
make
this
stuff
worth
more
automatically
alright.
So
that
was
super
super
easy.
Now
when
we
go
and
we
look
at
this-
we
did
a
cap
deploy
and
then
we
had
this
a
which
was
simple,
app
and
then
f
was
that
config
step,
one
minimal,
which
is
the
pointer
to
the
animal?
That's
the
file
name
directory
that
were
pointing
today.
So
the
question
is:
what
is
this
sort
of
simple
app?
A
A
A
A
There's
things
like
diffs
and
stuff
like
that
to
actually
be
able
to
do
the
three-way
merge
and
then
we
actually
have
like
labels
here,
where
there's
a
there's,
a
unique
app
thing
and
an
association
I
don't
understand
what
all
this
stuff
is:
I'd
love
to
explore,
I'm,
guessing
that
this
is
like
some
sort
of
hash
based
on
the
app
name
or
something
like
that
and
then
and
then
that
identity
actually
gets
put
into
here
of
our
own.
This
simple
app,
oh
okay,
so
just
a
timestamp
with
nanos.
A
A
Need
to
there
we
go
alright,
so
yeah.
So
now
we
have
that.
So
you
said
that
that's
just
a
timestamp
with
nanos
ka
pls.
Okay,
we
can
do
that.
Okay,
and
here
we
have
the
actual
label
here.
So
one
of
the
things
I'm
wondering
is:
how
do
we
actually
like?
Does
this
timestamp
get
written
out
anywhere?
Do
we
actually
know
how
do
we
actually,
if
I
do
another
apply?
How
does
it
associate
it
with
that
timestamp
like
if
I
do
like
a
camp,
deploy
simple
app
to
what
does
it
actually
do?
A
A
So
that's
actually
pretty
cool,
so
yeah.
So
there's
a
and-
and
the
other
interesting
thing
here
that
comes
into
this-
is
that
there
is
this
experimental
feature
and
cute
control
apply
called
prune,
which
actually
says
if
I
see
resources
that
are
in
the
cluster,
but
not
in
my
ammo.
How
do
I
go
through
and
actually
make
sure
I
can
delete
those
things
and
that's
actually
a
hard
problem?
It's
like
you
know
a
lot
of
times.
We
call
this
tombstoning.
A
How
do
I
actually
know
when
I'm
doing
a
DIF,
that
I
should
delete
something
versus
just
add
or
change
it,
and
so
having
identifier
for
the
app
like
this
becomes
a
critical
piece
of
that
puzzle,
and
so,
if
I
go
through
and
let's
say,
I
go
back
to
our
yeah
mall
here
and
I'm
already
going
off-script
so
Demetri.
This
is
what
I
do.
A
I'm
sorry
and
we're
gonna
actually
go
ahead
and
delete
the
service
that
we
have
here
and
I'm
gonna
save
this
and
now,
if
I
actually
do
a
deploy
again
same
commander
before
what
we're
actually
going
to
see
is
that
Oh?
The
change
that
we
have
here
is
that
we're
seeing
a
delete.
How
did
cap
know
to
do
that
right,
because
cap
knew
that
I
want
to
do
an
apply
now
the
apply
that
I'm
doing
is
just
a
deployment.
There's
a
service
in
the
cluster.
Now
like
cap
is
kind
of
stateless
here.
A
It
doesn't
know
it
lately.
At
least
on
this
side,
it's
stateless-
it
doesn't
know
anything
about
the
service
at
this
point.
How
does
it
know
that
it
actually
should
go
through
and
delete
the
service,
and
it
does
that
by
listing
all
the
things
and
looking
at
the
looking
at
the
the
labels
and
the
metadata
that
it's
keeping
so
that
it
can
actually
say,
ok,
I,
know,
last
time,
I
did
this
I
used
to
have
a
service
now
I
don't
have
a
service.
I
have
to
go
ahead
and
delete
it.
A
So
that's
a
piece
of
the
flow
here
that
is
missing
with
cube
control
applied.
That
is
here
with
cap,
which
is
much
more
amenable
to
sort
of
like
a
real
get
ops
flow
where
you
actually
both
add
and
delete
stuff.
Ok,
so
Dimitri
says
that
there's
app
to
label
connectivity
in
the
config
map,
ok,
so
yeah,
so
there
is
no
storage
locally
but
the,
but
that
that
metadata
then
gets
stored
into
a
config
map.
A
A
A
And
this
is
like
okay
and
then
so.
This
is
essentially
the
log,
so
so
so
what
cap
does
is
then
use
config
Maps
is
actually
a
data
store
to
keep
track
of
this
stuff,
which
is
actually
pretty
cool.
Shahar,
says
if
I
applied
a
resource
with
the
Q
control
and
then
started
using
cap.
Would
cap
know
about
the
resource
that
using
labels
that
cap
creates
I,
think
and
Dimitri?
If
you,
you
can
tell
me
if
I'm
wrong,
I,
think
cap
only
can
manage
stuff
that
it
was
used
to
apply
the
first
time.
A
A
A
If
I
do
this,
what
you're
gonna
actually
see
here
is
that
cube
control
apply.
Has
the
same
thing.
It's
gonna
give
me
a
warning
saying
like
no,
it
didn't
actually
ask
me
if
I
wanted
to
do
it,
but
it's
gonna
say
cube.
Control
apply
should
be
used
on
a
resources
created
by
either
cube
control,
create
with
save
config
or
cube
control,
apply,
and
so
save
config
in
create
actually
does
the
same
thing.
It
actually
writes
a
bunch
of
metadata
so
that
we
can
track
this
deployment
as
a
unit.
Okay.
A
Okay,
it's
gonna
actually
go
ahead
and
fix
up
the
metadata
on
these
things,
all
right,
so
yeah
cool
all
right,
so
that
I
think
that
would
look
like
it's
like,
because
when
I
did
the
apply,
probably
wack
the
metadata
and
then
when
I
did
the
the
cap
deploy
it
essentially
recreated
Andry
added
data
on
to
this
stuff.
Alright,
so
other
interesting
things
that
I
want
to
actually
explore.
A
Alright,
so
so
this
is
fascinating,
so
you
can
actually
go
through
and
start
restricting.
What
cap
can
do
is
you
can
say?
Hey
I
only
want
to
like,
like
make
sure
that
I
apply
to
these
particular
set
of
namespaces
or
I
want
to
go
through,
and
let's
see
there
were
some
other
stuff
you
can.
You
can
do
certain
types
of
filters
where
it's
like
I
want
to
apply
some
types
of
things,
but
not
other
types
of
things.
So
you
can
filter
out
sort
the
kinds.
A
A
It
could
go
ahead
and
put
Yambol
in
there
that
writes
random
stuff
into
a
namespace
bar
right,
and
so
that
means
then
that
you
have
to
you
know,
there's
no
way
to
actually
sort
of
cordon
this
stuff
off
when
you're
doing
something
like
a
get
ops
flow
with
something
like
cap.
What
you
could
do
is
you
can
have
your
apply
saying
like
oh,
when
I'm
in
directory
foo,
applying
the
yamo
for
namespace
foo,
I'm,
gonna
actually
configure
cap
so
that
it
actually
doesn't
allow
that
thing
to
touch
anything
outside
of
namespace
food
right.
A
So
that's
a
really
I
think
that's
a
place
where
you
might
use
some
of
these.
These
types
of
capabilities.
Another
thing
that's
really
interesting,
like
I,
said
every
time,
I
download
something
off
the
internet
and
try
and
install
it.
I
want
to
go
through
and
really
examine
what
it's
doing
and
what
types
of
resources
it's
going
to
be
creating
in
my
cluster,
if
you
remember
like
I,
don't
know
how
many
you
were
there
when
I
actually
did
a
review
a
scene
app
so
I
think
there's
a
lot
of
great
ideas
in
scene.
A
Am
the
idea
of
being
able
to
take
an
application
package
it
up
into
a
single
artifact
that
you
can
ship
around
is
awesome.
The
thing
I,
absolutely
don't
like
about
scene
app.
Is
that
it's
self
executable.
The
way
you
install
a
scene,
AB
application
is
essentially
take
one
of
the
containers.
That's
in
that
bundle
and
run
it,
and
then
you
handed
your
kubernetes
credentials
and
have
it
run,
and
so
that
means
that
the
thing
that's
deploying
your
application
is
the
same
thing.
A
A
A
What's
in
that
yamo
before
you
go
ahead
and
apply
it
and
so
I
think
having
your
installation
toolchain
be
different
and
separate,
or
your
packaging
tool
chain
from
the
thing
that's
actually
being
deployed,
it's
a
really
important
sort
of
sanity
and
security
mechanism,
and
so
that's
I
really
like
to
see
that
caps
moving
in
the
direction
of
actually
moving.
Some
of
that
verification.
Some
of
those
guardrails
into
the
deployment
mechanism,
so
Dimitri
says-
and
this
is
very
true-
this
is
there's
a
caveat
here.
A
It
can't
verify
what
the
deployed
containers
can
do
so,
like
you
know,
you
saying
it
doesn't
sort
of
like
start
to
sort
of
trace
through
which
service
accounts
and
what
our
back
is
and
all
that
so
you're
still
going
to
want
to
dig
a
little
bit
deeper
if
you're.
Actually
installing
cluster
wide
are
back
rules
but
but
I
think
you
know,
there's
room
for
sort
of
further
static
analysis
of
the
yamo
before
you
apply
it
and
I
think
that'd
be
a
really
interesting
direction
to
take
this
type
of
tool
chain
alright.
A
A
A
We
have
we
created,
two
objects,
the
service
and
the
deployment,
but
in
turn
those
things
actually
created
a
bunch
of
other
objects,
and
so
it
looks
like
cap
actually
scrapes
up
enough
data
out
of
kubernetes,
maybe
using
some
of
these,
the
owner
rafts
to
be
able
to
construct
this
tree
of
what
resources
are
parented,
to
which
other
resources,
that's
actually
pretty
cool.
That's
a
really
visual
ization
there
and
then,
let's
see
where
we
at
and
then
we
can
do
logs.
Oh,
this
is
actually
really
cool.
A
A
Well,
look
at
that!
I
have
okay,
it
says
hello,
stranger,
okay!
So
we
have
that
and
now,
if
I
do
the
logs,
we
can
actually
see
the
request
received
there.
So
I
assume
that
this
is
doing
like
F
is
a
follow.
Sort
of
a
law
live
tale.
I'll!
Do
that
in
the
background
start
the
port
forward.
Oh
wait
did
I.
Oh
I
just
stopped
the
port
forward,
so
I'll
just
do
a
foreground
on
that
and
then
I
can
do
this
and.
A
Yeah,
so
if
I
refresh
refresh
refresh
we're
getting
a
bunch
of
requests-
okay,
so
that's
a
pretty
common
development
flow,
the
port
forward
logging,
all
of
that
stuff,
I
think
so.
This
is
interesting
because
this
starts
to
overlap
with
things
like.
Oh
god,
what
was
the
the
Google
project?
That
essentially,
does
the
rebuild
redeploy
stuff
part
of
your
development.
Workflow
ends
up
being
like
I
want
to
see
logs
and
the
thing
I
want
to
be
able
to
redeploy.
A
There
are
very
few
places
in
this
world
and
I
think
this
is
one
of
the
things
that
makes
it
intimidating
for
new
users,
but
there's
very
few
places
where
system
a
and
system
B
are
truly
apples
to
apples.
Right,
there's
always
like
well,
this
thing
does
a
little
bit
of
that
and
a
little
bit
of
that
a
little
bit.
A
The
other
thing
and
I
think
that's
a
sign
that
there's
a
lot
of
really
great
innovation
going
on,
but
I
think
it
also
makes
this
stuff
be
incredibly
intimidating,
because
the
the
the
battle
lines
in
terms
of
where
the
products
are
where
the
projects
are,
how
they
relate
to
each
other,
are
still
very,
very,
very
fluid,
so
I'm
not
going
to
do
okay,
I'll!
Do
that
this
thing
here.
So
how
does
this
work?
A
A
Does
it
okay,
I'm
gonna
I
want
to
look
into
this
at
some
point
in
the
future
yeah.
So
this
is
different.
This
is
similar
in
some
ways
to
telepresence
port
forward
proxy.
Don't
use
proxy
but
yeah.
Okay,
so
it
sets
a
sets
up.
Packet.
Filter
rules
doesn't
change
config
files.
Okay,
that's
cool!
Does
that
work
on
the
Mac
I?
A
Wonder:
okay!
Well,
we'll
explore
that
another
time.
So
it
does
work
on
the
Mac.
Okay,
all
right!
So
now
we're
gonna
change
this.
We
have
an
environment,
hello,
TGI,
K,
so
we're
gonna
go
ahead
and
do
that.
So
this
is
okay.
So
if
I
help
to
Det
hello,
no
and
then
like
so
this
is
this:
is
the
yeah
Moe
thing
right
so
now,
I
actually
go
through
and
I
do.
A
A
Let's
see
what's
gonna
happen,
yeah,
okay
and
then
what
happened
here
is
that
the
error
that
the
server
barked
on
this
so
I
think
it
might
be
interesting
again,
more
validation,
I,
don't
know
if
this
belongs
in
ytt
or
or
or
cap.
But,
like
you
know,
there
are
tools
out
there
that
help
you
do
sort
of
preflighting
and
you
know
of
this
stuff
so
that
you
can
actually
go
through
and
see.
Do
schema,
validation
and
there's
dry
run
stuff
being
added
to
kubernetes.
That
might
help
here.
Also,
so
that's
actually
pretty
cool.
A
Okay,
so
but
we're
gonna
do
a
value.
T
GI
k,
we're
into
the
mod
I
say
yes,
so
you'll
notice
that
it's
waiting
for
it
for
the
deployment
to
actually
roll
the
thing
and
now
I
come
back
here
and
I'm
no
longer
running
my
proxy,
oh
and
then,
and
then
the
logs
are
actually
still
running
in
the
background.
So,
let's
see
if
this
works
so
or
forward,
okay,
there
you
go,
give
control
not
that
one
there
we
go
port
forward
service
so
now
that
thing's
running
okay-
and
this
is
really
cool.
A
A
Alright-
and
so
so,
apparently
so,
let's
just
TGI
K
I'm
gonna
go
through,
and
let's
do
this
I'll
change
it
again
and
Dmitry
is
saying
that
there's
a
see
that
actually
shows
changes
alright,
so
here
you
can
see
that
we're
actually
digging
a
little
bit
deeper
here
and
we
can
see
the
changes
and
yeah
super
cool,
stuff
and
I
start
seeing
that
something
about.
How
can
we
put
this
another
tool
chains?
How
can
we
actually
make
it
be
more
visual?
A
You
know
how
does
this
apply
to
get
ops
lots
of
exciting
stuff
that
can
happen
with
a
decomposed
tool
chain
like
this?
Alright,
so
here
we
can
do
like
differs
since
the
service
was
changed.
Nobody
ever
talked
about
it,
and
then
one
of
the
other
interesting
things
here
is
that
you
know
the
animal
that
is
getting
pushed
in
doesn't
have
to
come
from
disk.
It
can
actually
come
from
anywhere
one
of
the
tricky
sort
of
gotchas
here.
A
If
we
look
at
this
command
line
here,
can
you
all
see
this
is
that
here
we're
doing
helm
template,
which
is
a
great
way
to
sort
of
use
templates
client-side
before
we
before?
We
get
helm,
3
and
and
helm
template
generates
a
boat
loading
ammo
and
then
you
can
do
cap
deploy.
You
don't
have
to
write
this
stuff
to
disk.
A
So
last
time
I
tried
this.
If
you
didn't
specify
the
yes,
it
would
like
air
out
in
a
weird
way
and
so
I
think
having
like
I
think
from
a
user
experience.
Dimitri,
just
a
you
know:
if
you
forget
the
yes,
you
know
just
saying
something
like
hey,
you
know,
piping
into
standard
in
is
not
compatible
with
with
with
the
default.
You
know
rewrite
it
and
do
this
because,
because
otherwise
you
get
a
bunch
of
you
you're
like
what
the
hell
went
wrong.
At
least
that's
that's
what
I
got
all
right.
So
all
right!
A
A
Here
we
have
template
and
we
have
config
and
values.
Now
when
we
start
looking
at
a
template
here,
you
can
see
that
there's
this
special
thing
here,
where
it's
it's
it's
pound
at,
which
is
essentially
saying
this
is
a
command
to
ytt,
to
be
able
to
do
stuff,
and
so
there's
a
there's,
a
dialect
here
that
says
load
this
stuff
and
then
we
have
death
and
end,
and
then
this
is
how
you
actually
do
a
substitution
so
like
in,
and
you
know
you
know
you
might
do
foo
if
you
were
using
helm
right.
A
But
here
you
actually
do
do
this
particular
thing
now.
The
interesting
the
theme
on
is
that
this
is
structure
aware
right.
So
you
know
like
if
you're
out
throwing
helm,
charts
you've
got
a
like.
It's
like
you
do
helm
template
and
you
say:
oh,
my
indent
is
slightly
wrong
and
so
there's
all
these
helpers
to
make
sure
you
get
the
intent
right.
A
Think
I
can
do
this
bar
baz,
then
that
gets
put
down
into
the
selector
here
and
into
the
labels,
because,
like
a
lot
of
times,
yeah
Moe
Cooper
nameless
over
boats,
where
most
of
the
time
99%
of
the
time,
you're
actually
repeating
labels.
Again
and
again,
there
are
scenarios
where
you
don't
want
to
actually
have
the
exact
same
labels,
which
is
why
we
did
it.
A
But
if
I
go
ahead
and
do
that,
you
can
see
I
have
us
a
couple
of
things
here:
I'm
not
mucking
with
you
know,
indenting
anywhere
here,
and
so
that's
the
sort
of
recognizes
the
structure
aspect
of
ytt.
That's
really
cool!
Now
astute
readers
will
look
at
this
and
say
deaf
and
colons.
This
looks
a
little
bit
like
Python
and
and
it
is
kind
of
a
dialect
of
Python.
A
You
think
they
could
have
done
like
a
google
search
before
they
open
sourced
it,
but
whatevs,
and
so
star
lark
ends
up
being
a
contained
dialect
of
Python.
Not
only
that
and
I
think
this
is
super
cool
is
that
there
are
multiple
implementations
of
star
lark
and
so,
and
so
you
can
embed
it
directly
and
go,
and
it's
a
simple
enough
language
that
this
isn't
a
crazy
thing
to
do.
A
I
think
it
would
have
been
interesting
if
helm
three
had
actually
chosen
to
do
something
like
like
star
lark,
Skylark,
star
lark,
instead
of
instead
of
lua,
but
but
we
are
where
we
are
at
and
so
yeah,
and
so
what
happens
here
is
that
as
we
look
at
this
you're,
essentially
writing
sort
of
like
Python
intermixed
intermingled
with
the
amyl,
but
in
a
structural
aware
thing
which
I
think
is
is
really
cool.
The
one
difference
is
that
you
do
have
to
be
specifics
about
ends.
A
You
know
it's
a
gamble
is
whitespace,
aware
and
python
is
whitespace
aware,
and
so
these
are
not
two
great
tastes
that
taste
great
together.
So
it's
it's.
It's
it
sort
of
modifies
the
the
Python
esque
thing
to
actually
not
be
whitespace
dependent,
which
is
kinda
one
of
the
things
that
I
noticed
and
we'll
get
into
this
is
that
it
doesn't
support
non,
or
at
least
last
I
tried.
A
It
doesn't
support
non
code
labels
and,
like
you,
can't
actually
do
true
comments,
and
so
this
is
one
of
the
things
that
like,
if
you
just
take
plain
old,
the
animal
and
pipe
it
through
ytt
I
hit
an
error.
The
first
time.
I
did
this
but
okay,
but
let's
continue
on
with
the
with
the
blog
post
here
and
so
now.
What
we're
doing
is
if
we
look
at
this,
we've
gone
through
and
Hello
message
is
now
actually
coming
from
this
data
values.
A
Okay,
Mema
says
that
the
that
Nemo
is
one
of
the
other
authors
on
on
the
project
here
says
that
the
ability
to
have
regular
old
yamo
comments
is
fixed
in
the
latest
version,
which
is
exciting
because,
like
that
definitely
tripped
me
up
and
Confused
me
when
I
hit
it
so
yeah
I
think
the
goal
of
being
it
will
take
regular
old,
DMO
piped
through
ytt.
Get
something
that's
you
know
you
know,
semantically
equivalent
on
the
other
end,
is
sort
of
probably
going
to
be
the
starting
point
for
a
lot
of
lot
of
folks.
A
When
we
look
at
this
values.
This
looks
a
lot
like
you
know,
if
you're
using
helm
like
the
the
input
for
helm,
which
I
think
is
really
cool
and
so
yeah,
so
you
know
we
have
this
simple
sort
of
like
we've
pulled
out
some
values,
we're
actually
going
through
and
grabbing
this
stuff
and
then
we're
we're
off
to
the
races.
A
A
Don't
think
you
can
do
this
and
that's
probably
okay,
because
I
think
it's
a
templating
language.
This
is
the
type
of
thing
that
you
can
do
in
something
like
JSON
it
where
you
can
essentially
reference
other
parts
of
the
object
that
you're
modifying
as
you're
modifying
it.
This
was
a
very
common
pattern
in
borg
config
inside
of
google,
which
turned
into
GCL,
but
that's,
but
this
is
okay,
because
now
I
think
this.
A
What
this
means
is
that
you
have
to
be
much
more
explicit,
pull
it
out,
like
the
labels
here
versus
being
able
to
sort
of
create
spaghetti
by
referencing,
random,
stuff
and
and
random
things
yeah
or
it
adds.
A
lot
of
complexity
is
something
like
JSON
it
to
be
able
to
do
that,
because
you
move
from
being
sort
of
a
procedural
type
of
thing,
and
this
is
what
Dimitri
says
when
he
talks
about
ordering
to
something:
that's
purely
functional
where
in
functional
languages
you
write
it
in
order,
but
the
evaluation
is
totally
out
of
order.
A
It's
it's
a
logical
evaluation.
Okay,
so
let's
actually
see
how
this
works.
So
we
got
that
now
we
can
actually
go
through
and
and
we
can
go
through
and
I,
we
can
do
why
ytt
template
and
then
dash
F,
and
then
we
can
give
a
V
which
is
a
way
to
essentially
monitor.
Well,
let's
take
off
the
B
to
begin
with.
A
If
I
do
this,
this
essentially
goes
through
and
runs
the
evaluation,
outputs,
the
mo
the
the
the
ports
and
the
labels
and
everything
actually
get
passed
through,
and
so,
if
I
go
through
up
here
and
I
go
and
I
do
you
know
foo
bar
I
can
go
through
and
now
actually
you
can
see.
My
labels
have
foo
bar
my
selector,
so
we
actually
that's
sort
of
how
structure
works
and
nowhere
in
here
did
I
actually
start
mucking
with
indent
levels
for
yeah.
No,
but
a
lot
of
times
you
actually
want
to
be
able
to.
A
That's
what
this
means
here,
not
a
great
error,
though.
So,
if
you
see
something
like
this
as
you're
doing
these
things,
that
means
that
you
you're
not
allowed
to
actually
do
an
explicit
confirmation.
You
have
to
go
through
and
actually
just
say
yes
go
ahead
and
do
this,
and
so
now
we're
going
through
and
we've
applied
it
and
we're
off
to
the
races,
and
we
can
see
that
our
logging
is
still
running
in
the
background
and
this
guy.
A
You
know
this
guy
recognizes
the
same
app
because
it
was
called
simple
app,
and
so
this
is
sort
of
stimulates.
The
flow
of
I
started
with
plain
old,
the
ammo
I'm,
not
even
using
ytt
I.
Now
slipped
ytt
into
my
tool
chain.
I
can
continue
to
deploy
just
like
I
was
before
so
that's
pretty
cool,
and
then
the
other
interesting
thing
here
is
that
oh
man,
config
theory
right,
there's
like
there's
like,
should
be
a
PhD,
of
course,
and
this
there's
these
sort
of
two
different
schools
of
thought.
A
There's
the
patching
school
of
thought
and
then
there's
the
the
templating
school
of
thought
and
customized
is
all
about.
Patching
customized
prides
itself
on
not
actually
doing
any
templating,
but
they
actually
do
there's
a
couple
places
where
they
have
some
values:
they're
starting
to
blur
the
lines
and
do
a
little
bit
templating.
A
A
You
can
think
of
it
as
kind
of
a
primary
key
in
a
database
so
and
we
say
okay,
this
is
the
thing
that
identifies
the
row
that
I'm
talking
about.
That's
called
a
merge
key
and
that's
schema
specific
to
the
type
of
thing
that
you're
talking
about.
We
could
have
gone
through
and
actually
said.
Okay,
we
want
that
merge
key.
A
Instead
of
actually
making
a
list
make
it
a
map
hoist
a
merge
key
out
from
actually
being
that
thing
into
actually
being
the
key
to
the
map,
but
that
creates
its
own
challenges,
because
a
critical
piece
of
information
may
not
actually
be
in
the
subtype
and
when
users
read
the
ammo,
they
look
at
that
key
and
they're
like
is
this?
Something
I
can
change,
or
is
this
something
that's
intrinsic
to
the
system,
and
so
that
ends
up
being
a
little
bit
tricky
about
that.
A
So
so
Dimitri
actually
has
a
there's
a
document
that
starts
talking
about
overlays
and
I'm
sure
you
all
have
bumped
your
head
on
this
and
I
started
thinking
deeply
about
this.
So
let's
go
ahead
and
see
if
we
can
actually
see
that
do
ITT
I
see
Docs,
it's
pretty
thin
right
now
by
language.
So
this
is
Dogg's
language,
rough,
ytt,
overlays,
okay,
so
we
need
to
apply
left
and
right
sort
of
merges
these
things
in
yeah,
and
so
what
happens
here
is
that
when
you
do
this,
you
have
to
specify
the
map.
A
Key
tools
like
cube,
ctrl,
apply
or
actually
tools
like
customize
actually
are
kubernetes
schema
aware
enough
that
they
actually
know
how
to
know
they
can
read
the
map
key
out
of
the
kubernetes
schema,
and
so
that
ends
up
being
something.
That's
a
little
bit
trickier
to
wrap
your
head
around
with
with
ytt
okay.
A
So
let's
look
at
this
command
line
here
so
that
all
of
this
is
fascinating.
I
love
it
okay.
So
so
what
we're
doing
is
that
we're
actually
going
through?
Oh
actually,
yes,
okay,
so
we're
going
through
and
we're
evaluating
the
template
thing
and
it's
doing
kubernetes
user
and
then
we're
doing
another
deploy
and
we're
piping
that
as
an
input
and
we're
doing.
No,
no,
that's
not
the
right
thing.
A
A
Okay,
so
the
template
is
the
base
and
then
we're
specifying
the
overlay
as
another
file,
and
then
those
things
actually
get
merged
together.
This
is
slightly
different
from
customized,
because
customized
actually
has
a
you
know
in
the
in
the
base,
llamo
sort
that
specifies
the
application.
It
actually
has
a
base
member
that
says:
well.
Here's
the
base
customized
configuration
that
I'm
talking
about
there,
whereas
here
you
have
to
know
what
the
base
is
as
you're
actually
doing
this
on
the
on
the
command
line.
A
One
of
the
other
interesting
choices
with
ytt
is
that
it
doesn't
have
an
opinion
about
your
layout
on
disk
I.
Think
one
of
the
things
we
did
with
case
on
it
I
think
one
of
the
things
that
customized
does
is
that
there's
this
idea
that
if
you
lay
things
out
on
disk
in
a
specific
way,
it
has
implications
in
terms
of
the
relationships
between
different
files.
A
This
is
in
some
ways
inspired
by
things
like
you
know:
rails
Ruby,
on
Rails
right,
where
there's
a
sort
of,
don't
repeat
yourself,
dry
type
of
thing
and
the
one
of
the
ways
you
get
away
from.
That
is
having
opinions
about
how
you
lay
things
down
on
disk,
and
so
Nemo
says
that
you
can
also
drop
the
overlay
into
the
base
and
it
will
pick
but
but
then
they're
in
the
same
directory.
And
so
you
know
you
don't
get
that
separations
and
concerns
now
I.
A
Don't
think
this
is
a
bug
or
a
problem
with
ytt
I
think
what
this
may
be
is
an
opportunity
to
actually
create
another
tool
on
top
of
this,
that
essentially
runs
ytt
in
an
opinionated
manner,
maybe
drawing
some
values
from
a
separate
config
file
and
actually
implying
and
understanding
things
based
on
how
things
are
actually
laid
out
on
disk.
So
I
think
that's
another
example
of
maybe
a
separation
of
concerns
where
there's
different
ways
to
actually
do
this,
so
I
could
see
there
being
some
sort
of
K
14s
uber
tool.
That
knows
how
to
say.
A
A
Yeah:
okay,
oh
there's,
okay,
I'm
gonna!
Do
some
bash
tricks
here
like
right,
temporary
I
forget
the
bash
syntax
for
this
there's,
like
a
thing
that
says
like
run
this
command,
save
it
to
a
temporary
file
and
then
put
the
put
the
thing
into
the
into
the
command
line,
and
you
know
is
it
like?
Oh
god,
I'm
gonna
be
like
all
right,
I'm,
going
totally
going
down
a
tangent
here,
all
right,
I'm
gonna
do
that
later,
but
I
think
there
might
be
a
better
pattern
where
you
can
both
get
the
confirmation
and
okay.
A
So
we
can
go
ahead
and
do
this
and
then
we'll
go
ahead
and
apply
it
again
and
we're
gonna
see
the
changes.
There
were
no
changes.
What
did
I
do
I
think
I
copied
the
wrong
thing:
oh,
not
that
there
we
go
all
right,
and
here
you
can
see.
Now
we
have
three
replicas
of
this
thing
and
when
this
is
done,
you.
A
It
looks
like
it's
always
hitting
the
same
pod
and
wonder:
what's
going
on
here,
we
go
get
pods,
I,
think
there's
just
stickiness
in
oh,
that's
right,
so
port
forward!
Okay,
I
remember
this
is
this
is
something
less
than
optimal,
so
what
port
forward
does
it
doesn't
actually
forward
to
the
service
it
actually
yeah
I
wanted
to
fix
this
and
keep
control
board
forward.
It
uses
the
service
as
a
selector
to
pick
one
of
the
pods
and
just
forwards
to
that
that
kind
of
sucks
yeah,
so
Help
Wanted.
A
A
A
Because
then,
you
wouldn't
have
to
hard
code.
This
checks
if
there
is
an
Associated
source
code.
If
so,
builds
these
images
via
docker
and
finally
captured
building
digest.
Okay,
but
the
one
thing
it
doesn't
do
is:
do
a
docker
push
I'm
operating
on
a
remote
cluster,
and
so
you
have
to
do
things
like
you
know,
use
the
mini
cube,
docker
eval,
so
it
works
with
a
local.
A
Local
type
of
thing,
but
it's
not
going
to
actually
work
with
when
you're
doing
development
to
a
remote
cluster,
but
I
think
there's
like
could
be
pluggable
with
other
builders,
so
I
think
yeah.
Making
this
pluggable
with
other
builders
doing
cloud
builds
actually
making
sure
that
you're
doing
a
push,
picking
unique
names
as
you
do.
A
push.
I
think
that
would
all
be
interesting
ways
to
actually
sort
of
modify
this
and
actually
make
this
more
interesting.
A
But
now
you
can
see
how
this
toolset
starts
to
really
overlap
with
things
like
scaffold,
so
Demetri
says
what
are
your
thoughts
about
shipping
configuration
is
libraries,
one
example
would
be.
You
know,
k14
escapes
live,
oh
it
does
a
push
if
the
registry
is
specified
okay,
so
it
does
do
a
push
so
new
year.
What
are
you
thinking
about
with
a
library,
essentially
a
bunch
of
sort
of
Python
helpers
for
this
stuff?
I?
Think
that's
really
interesting.
A
A
I'm
torn
I'm
torn
here,
because
this
starts
to
I
think
hit
some
of
the
issues
that
we
hit
with
case
on
it.
Whereas
I
look
at
this
and
coming
from
somebody
who
knows
kubernetes,
llamo
I,
don't
see,
I,
don't
see
the
connection
between
this
and
the
kubernetes
ya
know
that
I
already
knew
and
there's
a
lot
of
Voodoo
going
on
here,
and
so
you
know,
one
of
the
things
that
I
think
you
know
I
think
is
interesting
is
when
we
look
at
the
config
space.
A
A
Actually
let
me
I
can't
do
it.
I
have
an
ipad
I
wanna.
I
want
to
get
it
to
the
point
where
it
can
actually
do
do
stuff
here.
Okay,
but
I
think
you
know
it's
one
of
these
things
where
here's
the
analysis
that
I
did
on
this
stuff,
no
yeah,
Mille
and
then
like
has
he
ammo
and
or
sort
of
simple
complex,
is
on
one
thing
and
then
we're
like
new
user
experience,
user.
A
And
so
you
know
I'm
looking
at
a
sort
of
an
analysis
like
this
and
when
I
think
about
this,
the
you
know
if
we
have
like
you
know
somebody
who
doesn't
know
yeah
mole
and-
and
they
don't
have
anything
already
like
like
new
users
that
have
an
experienced
kubernetes.
Ii
am
well
yeah,
actually
don't
exist
because
most
people
when
they
come
to
kubernetes,
they
start
with
the
ammo.
A
That's
where
all
the
tutorial,
our
and
so
I
think
we
need
to
create,
and
this
isn't
exactly
the
thing
I'm
gonna,
maybe
I'll
write
a
blog
post
on
it.
They
have
to
create
a.
We
have
to
create
a
smooth
path
for
them
into
this,
and
so
I
look
at
something
like
this
here,
and
this
is
just
an
enormous
leap
from
I-
understand
kubernetes
amyl
to
this
right.
In
some
ways
this
feels
like
it's,
the
similar
type
of
leap,
leap
of
I,
understand
kubernetes,
yeah
mol
to
like
blooming
right
we're.
A
You
know
this
I'm
sure
there's
a
lot
of
power
here,
but
there's
also
like
a
whole
new
thing.
I
got
to
learn
before
I
can
even
wrap
my
head
around.
What's
going
on
here,
so
that's
that
that
would
be
my
only
concern
here
with
this
stuff
I
know:
there's
a
whiteboard
behind
me!
I
can
do
that,
but
actually
I
set
up
my
camera
to
have
manual
focus.
So
if
I
actually
start
writing
on
the
whiteboard
I,
don't
think
y'all
are
going
to
be
able
to
read
it
I
thought
about
that.
A
So,
let's
see
so
this
does
Auto
Bild,
which
is
pretty
cool
and
so
I.
Think,
oh
and
here
we
go
here,
it's
pushing
to
the
registry.
So
here's
a
build
local,
pushing
to
the
registry
buildin
push
and
then
push
images.
True
push
images
reap:
okay,
I'm,
just
gonna!
Look
at
the
I'm
gonna
look
at
the
because
I
don't
think
we
have
enough
time
to
really
set
everything
up.
A
A
Okay,
so
there's
a
new
CR
D
here
it
c
rd
ish
thing
that
ends
up
being
inputted
too
okay.
This
is
really
interesting.
I,
like
this
metadata
that
actually
starts
telling
the
tool
chain
what
to
do,
is
actually
embedded
as
objects
but
get
stripped
out
before
they
actually
go
ahead
and
get
applied.
That's
a
really
interesting
idea,
and
so
this
says
that
you
know
we
have
a
source
here
and
I
think
is
that
part
of
the
build
also
yeah.
A
So
we
have
a
build
here,
so
this
actually
sort
of
follows
the
kubernetes
mechanisms,
but
it
actually
runs
locally
as
part
of
the
tool
chain
and
gets
tripped
out
before
it
gets
applied
to
the
cluster.
So
we
have
this
here
and
then
and
then
here's
the
image
where
we're
actually
using
it
and
then
push
we
have
okay,
and
here
you
can
actually
have
there's
a
new
type
of
thing,
which
is
called
image
destinations
and
we
have
things
like
asserts
that
actually
say
hey.
You
must
must
actually
specify
this.
A
So
that's
actually
I
really
like
I
like
like
that.
That's
really
cool
and
I'm
wondering
if
you
can
actually
template
this
stuff.
Also,
whether
this
image
name
actually
can
be
one
of
the
values
that
we
actually
pull
through
pretty
cool,
okay,
so
I'm
pretty
much
out
of
time
here,
but
hopefully
you
know
and
I'm
out
of
time
and
I'm
out
of
blog
post.
A
But
hopefully
you
know
this
gives
folks
a
an
interesting
idea
of
sort
of,
like
you
know,
the
the
ecosystem
and
the
sort
of
power
around
taking
this
problem,
breaking
it
down
into
some
component
pieces
and
then
building
back
up
based
on
that
really
really
interesting
stuff.
Something
I'm
really
excited
to
see
where
it
goes
from
here.
I
really
like
that
this
is
super
compatible
with
sort
of
the
get-ups
workflow
more
so
than
a
lot
of
other
tooling.
That's
out
there.
A
It's
going
to
be
interesting
to
see
if
you
know
what
does
this
look
like
in
conjunction
with
things
like
like
we
flux,
flux
is
actually
just
applied
to
to
become
a
CNC
F
sandbox
project,
and
so
that's
probably
going
to
be
happening
sometime
soon,
but
I
think
seeing
this
decompose.
Toolchain
for
me
is
super
super
exciting,
so
thank
you.
A
Dimitri
Thank
You
Nima
for
for
joining
and
for
building
the
tool
and
sharing
it
with
us,
really
exciting
stuff
and
I'm,
probably
going
to
be
doing
more
TGI
Kay's
here
for
a
while,
you
know
we're
gonna,
probably
have
Duffy
and
Josh
pick
some
of
that
up.
We're
trying
to
find
some
other
folks
too,
to
step
in
I
know
we
have
a
non
hefty
alum
who's
really
super
interested
in
doing
this.
A
Also
I'm
trying
to
convince
olive
power,
who
is
one
of
our
field
engineers
in
London
she's,
expects
expressed
some
interest
in
doing
it.
I'd
love
to
see
her.
Do
that,
maybe
we
change
up
the
time,
so
it's
something
more
local
for
her
be
a
little
bit
fair
to
the
rest
of
the
world
that
might
be
kind
of
fun.
So
thank
you,
everybody
for
joining
me
and
and
sticking
with
me
through
all
this
I
think
it's
been.
It's
been
a
blast
and
I
learned
a
lot
every
time
I
play
with
these
things.