►
From YouTube: TGI Kubernetes 098: CUE templating language
Description
Notes: https://github.com/vmware-tanzu/tgik/blob/master/episodes/098/README.md
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 are looking at the CUE templating language (https://cuelang.org/). This is a unique and interesting approach to wrangling YAML. Join Joe as he figures out what it is all about.
A
All
right
welcome
everybody
to
TGI
kubernetes.
My
name
is
Joe
Beda
and
I'm.
A
principal
engineer
here
at
VMware,
I
helped
start
the
kubernetes
project
about
five
years
ago
started
to
company
hefty.
Oh,
that
was
acquired
by
VMware
for
those
not
familiar
with
it.
Tti
kubernetes
is
a
weekly
ish
livestream
that
one
of
us
does
I
started
it,
but
we
also
have
folks
like
Duffy
and
Josh
and
others
that
are
Christian
and
Chris.
Did
it
a
long
time
for
a
long
time
that
helped
you
know
dude.
A
Also,
we
get
together
pick
a
new
technology
in
the
kubernetes
world
and
play
with
it,
and
we
all
learn
about
that
together.
So
that's
the
plan
today
do
I
sound,
okay,
I
know,
I,
look!
Okay,
I
was
at
a
customer
this
morning,
I'm
going
out
to
dinner
tonight,
so
I
figured
dress
up
a
little
bit,
so
you
know
usually
I'm
not
this
formal
for
TGI
K,
but
today,
I'm
dressing
up
a
bit
all
right.
A
Cool
yeah
YouTube
is
changing
up
a
little
bit
of
their
livestream
set
up
and
so
I'm
figuring
stuff
out,
and
so
this
is
my
first
time
use
in
their
a
new
thing,
but
it
seems
to
be
working
which,
which
is
good,
alright
well
first
I
like
to
say
hello
to
everybody.
I
think
one
of
the
things
that
is
humbling
to
me
is
that
the
tgia
audience
really
comes
from
all
over,
especially
considering
that
it's
1:00
p.m.
A
West
Coast
US
time,
which
is
like
the
worst
time
to
be
doing
this
because,
like
every
place
else
in
the
world,
you
all
are
like
you
know
done
for
the
week
and
out
drinking
or
sleep
in
or
even
it's
tomorrow
morning
already.
So
thank
you
for
everybody.
Who's
joining
me
from
all
over
the
place.
I
mean
Olaf
was
here
early
from
Copenhagen,
saying
hello,
l'm,
a
tea
is
a
is,
you
know,
I,
don't
think.
Hardly
ever
misses
one
nice
to
see
you
Martin
from
the
Netherlands
Cedric
he's
here.
A
I'm
gonna
be
pointing
a
blog
post
that
Cedric
wrote
a
while
ago
in
a
little
bit,
Shahar
Dimitri,
Marcel
good
to
see
ya.
Let's
see
ya,
Eric
mentioned
the
cute
Cointreau
floor.
The
episode
that
I'm
doing
today
I'm
going
to
be
talking
about
this
templating
language,
Templi,
nina
sky,
but
configuration
language
called
q,
CU
e-
and
I
did
this
live
on
the
show
floor
cube
con,
and
so
this
is
a
little
bit
of
a
repeat
of
that.
A
A
A
So
today,
let
me
go
ahead
and
sort
of
like
one
of
the
things
we
do
is
I
usually
try
and
spend
a
little
bit
of
time
going
over
news
of
the
week
interesting
stuff
happening
in
the
world
of
kubernetes
and
sort
of.
You
know
a
little
bit
of
discussion,
thoughts
on
that
so
hello
to
porch
ago,
and
so
let
me
go
ahead
and
switch
to
this
now.
These
things
are
all
up
in
T,
gik,
dot,
io,
/
notes,
I
have
that
link
posted
in
there,
and
this
is
a
hack,
MD
docket.
A
So
if,
as
we
go
through
the
episode,
if
there's
interesting
time,
codes
or
other
notes
that
you
want
to
put
in
here,
we
can
crowdsource
this
if
you
all
like
marco
from
milan
good
to
see
ya
so
the
so.
The
first
thing
I
think
you
know
this
last
week
I
was
supposed
to
be
there,
but
I'm,
just
exhausted
from
travel,
so
I
wasn't
those
last
week
was
reinvent
and
there
wasn't
a
ton
of
kubernetes
news,
except
for
some
new
eks
stuff,
which
is
really
interesting.
A
There.
The
one
caveat
to
be
aware
of
and
I
think
this
is
going
to
be
true
for
anything
in
this
class-
is
that
these
things
are
not
conformist.
Now,
I,
don't
know
the
individual
limitations
of
Fargate
I
haven't
had
a
chance
to
play
with
it
yet,
but
without
the
idea
of
a
node
there's
no
idea
of
things
like
a
like
a
daemon
set
right,
because
where
do
you
run
the
daemon
set
and
a
lot
of
times
folks
will
install
things
on
the
node
for
doing
security
or
monitoring
or
performance
analysis.
A
For
the
the
cluster
right,
so
you'd
start
up
a
control
plane,
and
then
it
was
up
to
you
to
bring
up
notes
and
attach
those
nodes
to
the
cluster.
Now
what
they're
doing
is
they're
supporting
all
of
that
automatically
and
so
they'll
actually
manage
those
node
groups
for
you.
That
starts
to
look
a
heck
of
a
lot
more
like
something
like
gke,
and
so
this
is
a
huge
feature
gap
both
with
Fargate
and
with
the
manage
node
groups
that
Amazon's
closing
here.
A
So
we
reinvent
is
obviously
overwhelming.
It's
like
sixty
some
thousand
people
in
Vegas,
but
Q
Khan
was
in
San
Diego
this
this
year
and
it's
a
it's
a
jam-packed
week
there
were
almost
12,000
people
there.
What's
fascinating
is
we're
seeing
that
the
conference
changed
a
little
bit
I
think
we
find
a
lot
of
folks
coming
to
cube
con
looking
for
solutions,
and
it
feels
very
much
like
a
vendor
conference.
A
But
when
you
go
to
the
keynotes,
it's
still
very
much
focused
on
projects
and
so
I
think
as
the
the
the
and
then
as
those
projects
to
start
to
diversify,
so
that
we're
not
just
talking
about
kubernetes
we're
talking
about
a
whole
bunch
of
other
projects.
That's
one
of
the
things.
That's
fueled.
The
growth
of
the
conference,
fueled,
a
lot
of
the
excitement
there,
but
I
think
has
caused
the
the
conference
to
may
be
fracture
a
little
bit.
I
think
different
people
are
getting
different
experiences,
so
it's
been
interesting
to
watch.
A
It
grow
over
time,
big
announcements.
There
is
here
at
VMware
we
announced
this
new
project
called
Andrea.
This
is
a
networking
solution,
so
CNI
sort
of
core
networking
solution
based
on
OVS
OVS,
open,
V,
switch,
very
mature
data
planed,
for
this
type
of
thing,
has
a
hardware
abstraction
mode
for
it
and
is
something
that
we
have
a
ton
of
experience
here
at
VMware.
So
the
the
networking
team
is
actually
getting
started
with
this
still
very
early
days.
We
want
folks
to
play
with
it.
A
The
goal
is
for
this
to
be
something
that
is
portable,
widely
usable,
a
really
good
starting
point
for
anybody
who
wants
to
to
have
solid
networking
for
their
cluster.
So
that's
something
to
check
out
will
probably
me
or
Duffy,
will
probably
be
doing
an
episode
in
Aintree
at
some
point.
Let's
see
so
George,
oh
and
there's
the
this
just
starts
playing.
A
A
Khan
George
pointed
me
at
this
here's
an
index
of
all
the
different
things
with
the
direct
links
to
the
videos,
and
so,
if
you
want
to
get
an
idea
of
the
different
talks
catch
up
on
them,
seeing
the
see
the
slides,
this
is
an
awesome,
awesome
research
resource,
so
Phillips
asking
in
the
chat.
How
does
Andrea
interact
with
NSX
well,
there's
I
think
we're
still
figuring
that
out.
A
I
think
the
the
idea
here
is
that
we
definitely
want
to
leverage
the
knowledge
and
the
understanding
that
we
have
from
NSX
T
with
OVS
and
bring
that
to
the
kubernetes
world
in
a
lightweight
way.
So
we,
you
know
when
we
talk
about
an
tree.
We
talk
about
it
being
kubernetes
native
and
that
the
control
plane
is
is
you
know,
leverages
kubernetes
and
kubernetes
ap?
Is
the
I
think
we're
gonna
find
ways
such
that
when
you
know
it's
running
on
NSX
T?
A
A
Networking
CNI
implementation,
but
there's
a
limit
to
the
number
of
IP
addresses
that
you
could
get
there
and
so
having
something
using
OVS
to
actually
sort
of
split
the
difference
between
those
having
some
pods
sadani,
and
I
other
pods
use
an
overlay
and
mixing
those
things
together.
I
think
that's
going
to
be
the
type
of
things
that
will
be
interesting
to
see
for
extending
an
tria
still
very,
very
early
a
early
day,
so
still
figuring
out.
You
know
what
it
means,
but
I
do
have
a
sticker
for
it.
So
you
know
look
at
that.
A
A
If
you
go
to
the
pod,
let's
do
you'll
see
this
and
I
believe
like
there's
videos
to
go
with
it
too,
and
so
I
did
an
episode
here
with
them,
and
you
can
see
oh
yeah
there's
my
face.
You
don't
want
to
see
that,
but
really
really
nicely
done.
The
huge
amount
of
work
from
from
Carly
Xie
and
code
actually
make
that
work
so
very,
very
exciting.
Let's
see
next
thing,
I
want
to
call
out.
This
is
really
cool.
A
A
Did
this
and
then
what's
super
cool
is
that
he
actually
had
one
of
the
books
printed
and
was
super
nice
to
send
it
to
me,
and
so
I
have
the
copy
here,
and
it's
like
it's
really
really
cool
to
actually
see
this
right
now
and
and
the
formatting
is
actually
really
nice
and
readable.
So
super
super
cool
stuff.
It's
it's
kind
of
crazy
to
see
a
written.
You
know
in
written
sort
of
hard
copy
form.
Alright.
So
thank
you
for
that.
Let's
see,
kubernetes
1.17
RC
2
was
out
making
its
way
along.
A
There's
usually,
let's
see
if
we
can
dig
in
a
little
bit
there's
like
the
draft
changelog.
That
folks
are.
This.
May
not
be
here,
maybe
some
yeah,
so
here's
so
you
can
start
seeing
okay,
oh
this
is
all
the
stuff.
You
can
start
seeing
all
the
changes
that
are
coming
here.
So
a
lot
of
a
lot
of
interesting
stuff
come
in
there.
A
I
don't
have
a
good
feel
in
terms
of
the
the
top-line
things
coming
with
1.17
I
think
you
know,
as
we
get
closer
I'm
gonna
be
digging
in
and
my
head
around
everything
that's
coming.
Let's
see
so
I
haven't
looked
at
this
yet
here's
a
our
operator,
George
pulled
these
things
together.
I
haven't
seen
this,
yet
this
is
cool,
so
this
is
a
robber
ATAR.
This
is
a
rust
based
operator
writer,
so
this
looks
really
really
fun,
something
that
I
want
to
dig
into
I,
don't
I've,
never
programmed
in
rust.
A
A
So
so
for
those
not
familiar
Jessie
Frizzell
Brian
Cantrell
started
the
startup
that
they
called
the
oxide
computer
company.
Their
goal
is
to
generate
essentially
new
data
center
hardware
and
kit,
along
with
a
integrated
software
system,
at
least
that's
what
I
understand
from
it.
It's
a
very
bold
play.
It's
a
big,
ambitious
goal
that
they're
going
after
you
know,
there's
a
lot
of
great
experience.
They're
super
smart
people.
A
They
got
a
long
road
ahead
of
them,
so
I
think
you
know
there's
still
very
much
at
the
beginning
of
their
journey
and
I'm
looking
forward
to
seeing
where
they're
going.
So
that's
my
take
on
that.
I
was
gonna
put
that
here,
but
it's
not
really
kubernetes
related,
but
I'm
excited
for
them
to
see
them
see
what
they
what
they
do
with
it.
So
very,
very
cool.
A
A
You
know,
reading
through
this
they've
gone
through
and
actually
done
things
like
generated
their
own
sort
of
services,
jobs,
cron
jobs,
Damon's
trained
jobs,
all
the
stuff
they've
essentially
created
their
own
C
RDS
for
a
bunch
of
these
things,
which
is
really
really
cool,
and
that
really
shows
the
power
of
the
extensibility
of
kubernetes.
If
you're
like
hey,
you
know
what
I
don't
like.
A
You
know
the
way
that
services
work,
I'm
gonna
actually
do
my
own
version
of
service
you're
perfectly
free
to
go
off
and
do
that,
so
that's
actually
really
really
cool
and,
and
then,
as
you
see
that,
like
you
know,
one
of
the
things
they'll
do
is
they'll.
Take
this
and
then
they'll
expand
this
out
into
something:
that's
more
fully
fledged,
and
so
the
interesting
thing
this
includes
like
a
deployment
and
stuff.
The
interesting
thing
in
my
mind
here
is
that
this
is
another
way
in
some
ways
to
actually
skin
the
cat
iran
configuration
management.
A
You
can
do
that
resolution
of
some
higher-level
thing
down
into
the
sort
of
granular
stuff.
You
can
do
that
outside
and
then
submit
the
granular
stuff
to
kubernetes,
or
you
can
do
that
live
inside
the
cluster
with
things
like
these,
like
what
Pinterest
did
here
and
so
that
duality
of
actually
having
it
be
a
preprocessor
step
versus
something
that
happens
in
cluster
is
something
that
I
think
we're
going
to
see
develop
over
time
and
it's
another
way
to
again
to
skin
that
that
configuration
cat
alright.
A
So
that's
the
the
pre-prepared
things
that
I
wanted
to
go
through
went
a
little
bit
long
there,
but
I
want
to
jump
into
queue
now,
if
you
all
are
ready,
so
the
in
terms
of
putting
queue
in
context,
there's
so
Cedric
who's
on
the
line
here,
put
together
this
blog
post.
That
I
think
does
a
good
job
of
laying
out
some
of
the
challenges
here.
A
I
just
need
to
change
this
one
thing,
and
so
maybe
you
had
it
by
hand
or
maybe,
like
you,
use
some
combination
of
make
and
awk
and
said
and
m4
to
be
able
to
do
text
replacements,
golang
templates,
that
type
of
thing
and
I
think
pretty
early
on.
You
find
that
that
sort
of
text
base
interpolation
really
runs
outta
steam,
and
it's
super
super
painful
to
author
and
I
think
that
the
greatest
greatest
example
of
this
is
helm.
A
Chart
templates,
the
templating
system
in
helm
is
I
think
how
succeeds
despite
the
templating
system,
not
because
of
it
I,
don't
think
anybody's
in
love
with
using
golang
templates
for
things
like
helm,
I
think
it's
just
honestly
a
matter
of
history
mostly
at
this
point.
The
next
layout
level
is
like
data
layering
with
customize.
What's
interesting
and
customizes
I
think,
as
we've
seen,
customize
continue
to
grow.
A
It
with
your
thing,
execute
it
there,
which
ends
up
starting
to
blur
the
lines
between
that
and
something
like
a
ytt
that
uses
star
lark,
which
is
a
Python
derivative.
And
so
the
next
step
that
Cedric
defines
here
is
a
data
configuration
language,
and
this
is
something
that
is
turing-complete
built
for.
A
Essentially,
dealing
with
large
amounts
of
configuration
that
needs
to
be
validated
schematized
specialized
and,
and
so
the
the
previous
thinking
on
this
is
that
these
things
sort
of
go
in
a
loop
where
people
say:
hey,
I'm,
gonna
use
llamo
as
a
simple
format:
I'm
gonna
write
code
to
do
it.
Okay,
now,
just
just
do
it
in
code,
oh
my
god
that
I'm
writing
code
to
do
everything.
I
thought
this
was
supposed
to
be
simple.
A
Let
me
create
a
higher
level
animal
to
do
it
and
then
that
cycle
cycle
sort
of
starts
all
over
again,
and
so
that's
the
traditional
way
that
this
stuff
actually
goes
and
I
think
we're
finding
that
folks
are
like
hey.
Let's
see
if
we
can
split
the
difference,
let's
see
if
we
can
do
something
that
starts
off
feeling
simple,
but
then
those
sort
of
coding
features
are
brought
on
as
necessary
and
I.
A
Think
that's
when
we
look
at
these
DC
ELLs
and
data
layering
techniques,
where
we're
still
experimenting
in
that
space,
I
haven't
given
up
yet
I.
Think
the
the
other
way
of
actually
sort
of
attacking
this
and
I
don't
think
it's
I
would
add
a
fourth
category
here,
which
is
you
know,
configuration
generated
from
general-purpose
languages
and
so
I
think
that's
when
you're,
using
something
like
JavaScript
or
Python
or
whatever
to
actually
generate.
Not
some
sort
of
you
know
specialized
language
but
you're,
using
a
general-purpose
language
to
generate
your
config
and
I.
A
Think
something
like
balloony
would
be
an
example,
an
example
of
that.
So
very
cool.
There's
a
lot
to
go
here,
but
this
actually
does
an
intro
of
Q.
What
makes
Q
specials
of
sort
of
types
vs.
values
think
that's
what
we're
going
to
be
going
into
a
lot
today
and
there's
a
great
tutorial
in
queue
around
kubernetes
and
we're
going
to
start
digging
into
that?
Also,
okay.
So
if
you
go
to
queue
length
or
queue
length,
org
stands
for
configure,
unify,
execute,
I
think
this
is
again
domain
base.
Naming
mine.
A
My
guess
is
that
Marcel
got
the
domain,
so
this
is
the
name,
but
but
basically
it's
a
it's
in
the
style
of
a
programming
language
where
there's
a
set
of
directory.
There's
files,
you
run
a
command
on
that
that
command
takes
input,
puts
output.
This
does
not
talk
to
kubernetes
directly.
It's
still
left
up
to
you
to
actually
take
the
result
in
yeah
Mille
and
find
a
way.
Oh,
the
name
came
first,
okay,
so
I'm
wrong
q,
just
without
the
Cu
II
was
taken
alright,
but
I.
A
Think
the
interesting
thing
and
I
think
this
is
what
we've
seen
is,
as
people
have
broken
these
things
down
separating
out
the
configuration
language
from
the
workflow
for
how
you
apply.
This
is
an
interesting
sort
of
evolution
that
we're
seeing
here.
I
think
similar
to
this
would
be
like
YT
TJ
sonet.
Those
things
are
all
sort
of
sit
outside
of
the
application
domain
and
I
think
we're
also
finding
that
this
configuration
problem
well,
I
think
is
best
known
in
kubernetes
world.
A
In
this
vein,
whether
they're,
kubernetes,
based
or
not,
the
the
ytt
stuff
came
out
of
a
lot
of
experience
in
the
Bosch
world,
which
also
has
a
lot
of
yeah
Mille
to
be
able
to
configure,
and
so
there's
a
lot
in
common
across
these
things
and
then
Marcel
who
wrote
this
his
history
is
building
a
similar
system
that
sort
of
grew
organically
a
little
bit
inside
a
Google
called
GCL,
google,
config
language
or
general
config
language
I,
forget
which
it
is
so
a
lot
of
lessons
from
there
being
applied
here.
Also.
A
So,
if
you
start
digging
into
the
documentation
good
place
to
start
here
is
there's
a
tutorial
and
tours
down.
Here
is
interesting,
because
this
actually
goes
into
sort
of
like
a
talk
of
the
language,
but
then
also
there's
integrations
here
which
talk
about
hey.
You
can
generate
Jason
yamo
and
knows
how
to
actually
derive
a
schema
from
go,
we'll
get
into
that
details,
protobuf,
open
api
and
CR
DS
and
then
raw
knowing
how
to
determine
things
from
from
kubernetes.
A
A
Work
well
there,
but
as
they
find
their
way
to
the
outside
world,
there's
lessons
that
are
learned
that
can
be
applied,
but
then
also
there's
requirements
and
realities
in
the
outside
world
that
don't
necessarily
apply
within
Google
also,
and
so
these
second
systems,
like
you
like
kubernetes,
like
you
know
and
I,
think
you
know
the
an
example-
would
be
scuba
with
Facebook,
with
honeycomb
doing
that
as
a
start-up
are
interesting
points
where
it's
like.
Essentially,
people
taking
these
ideas,
mixing
them
with
the
real
world
and
then
new
things
kind
of
come
out.
Yeah.
B
A
Differences
I
think
between
BCL
and
in
kubernetes
and
the
borg
ecosystem
is
that
bcl
generated
a
set
of
configs,
but
there
was
still
a
lot
of
sort
of
handwritten
code
to
be
able
to
apply
that
to
a
borg
instance.
The
the
borg
api
was
not
as
regular
as
the
kubernetes
api
and
it
didn't
sort
of
have
the
kubernetes.
It
doesn't
have
the
kubernetes
resource
model.
A
So
a
lot
of
the
extensibility
and
controller
patterns
that
we
see
with
the
kubernetes
actually
don't
exist
in
borg
at
all,
which
I
think
is
a
really
interesting
thing,
and
so
that
meant
that
BCL
was
actually
pretty
specialized
for
board.
Whereas
GCL
was
like
hey,
you
want
to
create
a
proto.
We
can
create
a
proto
for
you.
Correct
me
if
I'm
wrong,
Marcel
I
think
that's
the
way
that
I
remember
this
stuff
coming
all
right.
So,
let's
start
digging
into
what
queue
is
there?
Is
this
very.
A
Computer
science
II
talk
about
the
logic
of
queue
and
the
logic
here
is
not
like
logic
in
terms
of
it's
more
like
you
know,
language
logic.
So
if
you're,
a
language
nerd
which
I'm
not
and
I
kind
of
wish,
I
was
I,
don't
have
the
grounding
there.
This
is
actually
a
great
place
to
start,
but
I
think
a
lot
of
folks
will
do
better
by
actually
dealing
with
the
tutorial
here.
A
That
actually
goes
through
sort
of
some
of
the
concepts
with
Q,
and
so
the
first
thing
to
recognize
is
that
Q,
when
you're
using
it
in
its
simplest
form,
looks
a
lot
like
a
friendly
JSON,
and
so
here's
a
Q
file
called
JSON
q
and
and
you
can
go
through
and
easily
export.
This
and
it'll
just
come
out
as
JSON,
and
so
you
can
see
a
lot
of
the
niceties
here
like
you,
don't
have
to
quote
all
the
keys.
A
You
can
leave
the
commas
off.
You
can
have
commas
at
the
end.
You
can
have
comments
in
it
all
the
things
that,
when
your
hand,
authoring
JSON,
you
wish
you
had.
Q
has
those
things
out
of
the
gate,
and
so
let's
go
ahead
and
actually
just
sort
of
try
this
out
just
to
show
that
hey
this
works
now
the
one
thing
I
forgot
to
do
is
I'm
running
a
slightly
old
version
of
Q,
says
version
custom,
we're
gonna
install
the
latest
version
of
Q
here.
A
A
A
Cool
all
right,
so
all
right
so
now
we
got
it
installed.
Let's
go
back
so
I
think
like
I
said
so.
So
let's
try
and
actually
sort
of
do
this
and
we'll
actually
see
we'll
play
around
with
this
and
see
how
this
works
touch
test.
Iq
code
test
IQ.
Now
one
of
the
challenges
for
creating
a
new
language
from
scratch.
Is
that
don't
wait?
What's
going
on
and
every
time
I
start
visuals
I
thought
I
already
did.
This
is
that
you
need
to
do
language
modes?
A
You
need
to
do
syntax,
highlighting
github
doesn't
know
how
to
render
it.
So
that's
you
know
so
so
Q
is
still
relatively
new,
so
I,
don't
think
any
of
those
language
modes
in
in
Visual.
Studio
vs
code
are
actually
for
this
Q.
They
might
be
for
something
different,
but
we
can
go
ahead
and
we
can
type
that
we're
not
going
to
get
language
highlighting
unfortunately,
well
there's
a
VIN
version
for
it:
okay,
cool,
okay
and
now
we
can
do
Q
export
test
Q
and
you
can
see
now
it
exported
the
JSON
and
I
betcha.
A
So
sorry,
this
is
probably
this
is
probably
different.
Q,
it's
a
different
cue
cue
sheet:
Oh
Q.
She
dad
do
you
remember
cue
sheets,
so
cue
sheets
were
this
thing
for
when
you
have
a
long
audio
file
when
you
like
rip
a
CD,
it's
a
thing
that
actually
gives
you
the
tracklist
and
stuff.
So
Joel
says
that
there's
a
vyas
code
extension.
Do
you
know
what
it's
called
Joe?
What
do
I
got
to
do
that.
A
Now
I,
don't
see
it,
it's
not
in
the
alright.
Well,
we'll
dig
into
that
later.
It
says:
restart
I,
just
restarted
it!
Well,
it's
not
in
the
marketplace!
Yet:
okay,
okay!
So
there
we
go!
So
that's
how
it
goes
now
that
I
think.
Similarly,
okay,
let's
see
if
this
thing
there
is
probably
a
way
to
export
yam,
all
right,
cue,
export,
yeah
out,
yeah
mole
test
queue
boom
and
then
what
does
text
look
like?
Oh
it's.
B
A
A
Okay,
so
the
key
thing
about
queue-
and
this
is
like
in
it
sort
of
bakes
your
noodle
a
little
bit
is
that
types
and
values
are
actually
part
of
the
same
sort
of
hierarchy,
and
so
what
happens
is
that
you
can
take
two
things
and
merge
them
and
and
they
can
merge
as
long
as
they
actually
are
congruent
with
each
other.
And
so
you
can
take
something
like
a
schema
here
which
says:
I
have
a
municipality.
A
A
Cannot
convert
incomplete
value
string
to
JSON,
oh
I,
see
I.
Think.
Is
there
a
way
to
say?
Oh
I,
think
if
you
do
the
double
colon
here
that
says
that
don't
bother
exporting
that
okay,
there
we
go
boom.
So
so,
essentially,
what
we're
saying
here
is
that
now,
if
I
say
hey,
you
know,
capital
is
a
string.
Also,
now
what
we're
gonna
say
here
is:
oh
you
have
you
have
true
and
string
you're
trying
to
merge
these
things
across
these
two
different
lines:
lines:
four
and
nine.
A
A
Name
is
a
string
or
an
int,
so
now
Moscow
works,
but
I
can
also
go
and
do
42
here
and
that'll
work,
because
we
can
essentially
construct
these
constraints
and
in
the
42
is
it
compatible
with
string
and
int,
and
these
things
are
actually
order,
independent,
also
I,
believe,
and
so
you
know,
we
can
specify
things
like
that
and
doesn't
matter
same
old
thing.
So
that
is
like
when
we
start
talking
about
in
queue.
And
can
you
all
see
this?
Let
me
make
it
a
little
bit
bigger.
Sorry.
A
We're
going
to
to
that
as
we
start
going
through
the
kubernetes
examples,
but
the
idea
is
that,
generally,
at
the
root
of
your
hierarchy,
you're
going
to
have
a
bunch
of
schema
in
the
subdirectories,
you
might
have
some
policy.
That
starts
to
specialize
things
and
then
the
leaves
you'll
actually
have
the
fully
qualified
things
that
you're
dealing
with,
and
so
the
way
that
things
work
inside
of
a
module
is
that
it
actually
loads
things.
It
loads
the
queue
files
up
the
directory
hierarchy
to
be
able
to
create
this
sort
of
inherited
system.
A
Interesting
way
and
then
there's
tools
to
do
automatic
refactoring
with
this
stuff,
which
is
really
really
fun,
also,
okay,
so
that
is
that
idea
there.
If
fields
are
duplicate,
that's
fine,
they'll
merge
as
long
as
they're
the
same
value
and-
and
we
have
duplicates
here
so
this
is
an
example
of
this
okay,
and
so
this
is
similar
that
City
thing
that
I
did
where
you
can
have
a
schema.
A
So
that's
that's
pretty
cool
too,
and
and
that's
essentially
and
so,
oh
and
then
the
final
thing
is
that
you
can
go
through
and
you
can
do
so.
We
can
combine
these
things
together
and
I
can
say
it's
a
municipality
and
it's
this
and
that
and
in
essentially
joins
those
things
together.
So
that's
sort
of
a
shorter
way
of
actually
doing
this
card.
Lycia
how's
it
going
good
to
see
you
so
same
sort
of
thing
going
on
there
with
that.
A
So
that's
a
way
to
sort
of
bring
those
things
together
and
if
you
look
at
this
and
if
you
know
JSON
it
and
I
like
you
know,
this
is
a
little
bit
like
the
the
combination
sort
of
operator
and
JSON
it.
But
the
one
thing
here
is
that
this
is
still
order,
independent
here,
and
so
that
means
that
you
know
this
can't
this
can
actually
sort
of
like
it
can
specialize,
but
it
doesn't
override
and
I
thinking,
BCL,
GCL
and
json
it.
The
thing
on
the
right
of
that
sort
of
join
thing
can
actually
override.
A
So
if
I
actually
have
this
be
I,
don't
know,
is
there
a
historic,
different
name
for
Moscow
I'm
sure
there
was
because
every
Russian
city
was
named
33
times
like,
but
let's
call
it.
You
know
New
York
right
if
I
go
ahead
and
do
that
that's
going
to
give
me
an
error
because
we're
actually
conflicting
New,
York
and
Moscow,
and
so
this
thing
is
not
an
override.
It's
a
join
assuming
that
you
can
actually
take
these
that
these
things
are
mirja,
believe
art
of
the
same
hierarchy
and
there's
sort
of
like
fancy.
A
A
That
you
know
some
of
these
things,
oh
and
then.
Finally,
the
last
thing
I
can
do
is
I
can
have
something
here
being
like
cool.
You
know
or
like
tacos.
You
know
so
Moscow
I'm
gonna
say
has
ten
taco
shops
right.
So
this
is
actually
part
of
my
schema,
but
now
it
actually
in
some
in
some
ways,
becomes
like
a
like
a
default
here
and
you
can
actually
do
something
like
we
can
do
number
or
10,
which
now
says.
Okay,.
A
There's
like
there's
like
it,
what
is
the
default?
There's
oh
I
can
do
that
and
then
I
can
put
a
star
there.
I
believe
is
the
yeah.
Oh
wait!
No,
it
was
it
before
there
we
go
yeah
the
star,
and
so
this
ends
up
being
like
hey
I
can
do
this
constraint.
I
have
a
default
of
10,
but
number
so
now
I
can
go
through
and
I
can
do.
Num
tacos,
but
I
could
also
have
instead
of
10
here,
I
could
have.
A
My
default
could
be
no
tacos
right,
and
so
my
my
number
of
tacos
could
be
10
or,
if
I
sort
of
take
this
off.
Now
it's
no
tacos
as
a
string
right.
So
you
these
sort
of
Sentinel
values
in
there.
Also.
This
is
very
useful
as
we're
dealing
with
some
of
the
sort
of
idiosyncratic
seas
of
kubernetes
yam.
Well,
things
like
ports
can
be
in
or
a
port
name.
So
it's
the
indoor
stream
type
of
thing
can
actually
be
be
surfaced
here
in
a
native
way,
all
right,
so
that
is
sort
of
the
basics.
A
Here,
there's
a
lot
more
going
on
here.
I,
don't
want
to
try
and
go
through
all
this
I
think
the
thing
that
I
want
to
go
through
next,
which
is
kind
of
fun,
and
this
is
off
the
notes
here-
is
this
kubernetes
tutorial,
and
this
is
a
whole
sort
of
refactoring
flow-
we're
not
going
to
get
through
all
of
this,
but
we
can
get
through
a
lot
of
it,
which
I
think
is
really
really
interesting.
So
the
first
thing
that
we're
gonna
do
here
is:
if
we
go
into
the
queue
I
thinked
it
from
github.
A
All
right,
sorry
about
that,
yeah
I,
think
you
know
something
with
OBS
and
the
new
YouTube
streaming
stuff.
This
stuff
is
always
a
little
bit.
Flaky
I
think
we're
good.
Now,
okay,
Oh
Martin
says
no.
Are
we
back
Martin
for
you
other
folks
say
back
okay,
so
what
I
did
is
I
pulled
out
of
the
okay
cool
I
pulled
out
of
the
cube
github
repo,
a
sample
set
of
kubernetes
sort
of
microservice,
see
things
in
and
and
then
pulled
that
into
a
temporary
directory
will
start
vs
code
with
it
and
apparently.
A
Okay,
and
so
what
we
have
here
is
we
have
a
whole
bunch
of
directories
that
our
services
we
have
front-end,
which
has
this
bartender
thing,
and
we
see
this
pattern
where
we
have
a
kubernetes
service
object.
We
have
a
kubernetes
deployment
object
and
then,
like
you
know,
and
and
and
this
is
pretty
typical-
that
you'll
always
have
my
EEP.
A
A
All
the
time
now,
Marcel
tells
me
that
this
is
an
anonymized
version
of
a
larger
service
as
an
example,
and
so
now
the
other
interesting
thing
is
that,
like
you
know,
we're
probably
not
going
to
deploy
this
today,
we're
just
going
to
be
using
this
to
sort
of
manipulate
yamo,
and
then
you
can
use
something
cap
which
is
part
of
the
K
14s
toolset,
to
be
able
to
deploy
these
things
or
you
can
use
cube
control
apply,
or
what
have
you
all
right?
So,
oh
there
we
go.
Okay,
cool,
so
going
through
the
tutorial
here.
A
The
first
thing
that
we're
going
to
do
is
we're
going
to
call
Q
mod
in
it
and
what
this
does
is
it
creates
a
directory
here
called
Q
dot
mod.
Now
this
is
with
things
like
this
module,
dot,
Q
and
stuff,
like
that.
This
thing
is
in
some
way,
similar
to
your
like
dot
git
file,
where
it
provides
a
lot
of
context
for
the
for
the
sort
of
queue
installation.
A
You
I
believe
you
want
to
check
this
in
with
the
rest
of
your
configuration
into
source
control.
So
that's
the
idea
there
and
then
so
there
we
go
and
now
what
we
can
do
is
we
can
go
into
services
and
do
Q
import
and
things
like
the
dot,
slash,
dot,
dot
dot.
That's
obviously
a
convention
borrowed
from
go
and
then
we
must
specify
a
package
name
and
so
we're
just
gonna
call
this
P
cube.
Ok,.
A
This
flag
or
files
flag
needed
okay.
So
now
what
this
is
telling
me
is:
it's
like:
hey,
wait,
a
second
I'm
trying
to
import
stuff,
but
the
way
that's
what's
causing
some
confusion
here
is
that
I
have
multiple
documents,
and
so
Q
doesn't
know
how
to
import
multiple
documents
in
natively,
because
it
generates
a
single
document,
but
right
now
we're
importing
a
bunch
of
yamo.
A
A
A
I
have
to
give
it
to
you
if
we
look
at
this,
this
ends
up
being.
If
you
ignore
these
things,
this
ends
up
essentially
being
the
exact
same
as
the
the
yamo
that
we
that
we
started
with.
So
that's
a
relatively
straightforward
way
to
actually
bring
these
things
together
and
then,
let's
see
so,
we
can
go
through
and
do
tree.
A
And
you
can
see
that
okay,
for
each
of
these
things
we're
good
to
go,
there's
some
other
places
where
we
have
config
maps
and
stuff
and
we'll
get
to
some
of
that
stuff
in
a
little
bit.
That's
pretty
cool
okay,
so
it
has
us
looking
at
Mon,
prometheus,
okay,
so,
okay,
so
now
this
is
the
next.
The
first
cool
feature
is
that
Q
has
built-in
helpers
to
be
able
to
encode
and
decode
into
into
yamo,
along
with
JSON
and
other
things
too.
A
So
if
we
look
at
so
one
of
the
things
if
you've
ever
and
the
reason
why
I
did
this
is
that
Q
is
used
for
the
sto
configuration
and
SDO
is
really
good
at
doing
this
like
pattern
here,
but
we
also
see
it
in
places
like
like
Prometheus
here
so
Prometheus
has
to
see,
which
one
are
we
supposed
to
be
looking
at
the
config
map
Q.
This
is
a
little
bit
big.
A
Package
cube
alert
rules,
okay,
so
okay
yeah.
So
when
we're
looking
at
oh,
this
is
the
yamo.
If
we
look
at
the
Q,
what
we
see
here
is
that
alert
rules
uses
this
triple
tick
here,
which
is
similar
to
like
sort
of
Python,
quoting.
It
says
that
everything
under
here
you'd
be
easier
if
we
had
his
syntax
highlighting
for
Q,
but
this
is
just
plain
old
strings
right,
so
I
can
go
through
and
make
this
be
invalid.
A
Yeah,
MO
and
Q
has
no
idea
about
it
right
so
like
we're
just
passing
strings
through,
and
so
one
of
the
things
that
complicates
when
you're
doing
things
like
Prometheus,
where
you
have
say
Y,
Amal
inside
of
a
config
map,
that's
included
in
another
thing
is
that
you
end
up
with
this
inability.
You
have
these
blocks
huge
blocks
of
strings
that
are
not
being
sort
of.
A
Into
your
configuration
system,
and
so
one
of
the
things
that
can
happen
here
is
that
if
you
actually
give
a
R,
it
tries
to
auto
detect
when
a
string
looks
like
valid
JSON
or
Y
Amal,
and
automatically
do
some
some
magic
to
be
able
to
deal
with
that.
So,
let's
go
through
and
we'll
we'll
run
our
import
command
again
and
we'll
give
it
a
cap
R
on
it.
And
now,
when
we
look
at
this,
if
this
all
goes
as
planned,
wait
did
that
not
work?
Oh
I
need
to
go
to
services,
maybe.
A
My
in
the
wrong
directory-
oh
wait,
which
oh
I'm
modified.
Let
me
don't
save
there.
We
go.
Ok,
cool,
ok,
sorry
about
that.
That
was
all
me.
So
what
we
have
here
is
that
okay,
so
he's
importing
sort
of
the
the
Amal
encoding
package
and
giving
it
a
unique
name
here.
So
this
is
just
a
hash
just
to
make
sure
it
doesn't
conflict
with
anything
else.
I,
don't
think
6,
566
3
means
anything,
but
now
what
we
can
do
is
we
can
have
an
hidden
structure
here
called
cue
alert
rules.
A
The
underscore
right
now
means
that
hey
this
won't
be
output
later
and
I.
Think
Marcel
says
that
there's
he's
working
on
an
alternative
way
to
actually
do
that
and
then
you
can
take
that
value
and
you
can
marshal
it,
and
this
has
convert
that
structure
into
a
yamo
string,
and
so
now
we
get
all
the
features
of
queue,
but
those
things
can
actually
be
used
to
help
define
the
alert
rules
in
a
structured
way,
and
so
this
is.
A
A
A
Yeah,
okay,
so
now,
if
we
run
this
thing
here
this
this
grabs
a
snapshot
of
our
output
here.
Okay-
and
what
does
the
dash
see?
Do
you
does
that
concrete
require
the
evaluation
to
be
concrete?
That
means
you
can't
leave
anything
saying:
hey.
Should
this
should
be
a
string?
It
has
to
actually
be
the
thing
that
it's
supposed
to
be,
and
so
this
actually
goes
through
and
evaluates
all
the
different
files
in
this
directory,
all
the
different
and
merges
those
into
a
single
document
which
is
really
really
interesting.
A
A
Okay,
so
we're
taking
this
thing
so
now
we
have
this
thing
called
cube
queue
and
what
we're
gonna
be,
what
we're
gonna
be
doing
is
I,
don't
know
why
we
copy
it
when
we're
like
gonna
be
modifying
it,
but
we're
gonna
essentially
be
replacing
it
with
this
stuff.
Here
and
so
we
could
go
through
and
sort
of
edit
this
down,
but
I
think
instead
we're
gonna
be
saying
through
so
now.
This
is
establishing
a
schema.
A
What
we
expect
of
all
our
thar
sub
objects-
and
it's
also
establishing
some
defaults,
and
so
those
defaults
will,
let
us
simplify
and
use
some
of
the
refactoring
tools
built
into
queue.
But
basically,
what
this
says
is
that
everything
under
service,
no
matter
what
it
is,
we're
gonna
take
what
it
is
and
assign
it
to
a
temporary
variable,
called
ID
and
then
we're
gonna
say
well,
the
name
of
the
service
and
the
name
of
the
app
label.
A
A
So
this
is
one
of
those
things
where
all
the
labels
across
all
your
stuff,
just
line
up,
which
is
probably
going
to
be
the
90-95
percent
case.
Similar
type
of
thing
happening
here
for
deployment
start
with
a
default
number
of
replicas
to
be
one,
but
it
can
be
any
integer,
and
then
the
template
has
a
container
where
the
name
of
the
container
lines
up
with
the
idea
across
all
of
these
things.
So
now
this
is
a
great
place
to
start.
A
A
There
we
go
so
now
we
got
a
bunch
of
errors
and
what
these
errors
are
telling
us
is
that
we
started
at
saying:
hey.
We
have
to
have
this
schema.
These
things
must
actually
line
up
and
we
actually
found
some
places
where
they
didn't
line
up,
and
so
one
example
here
would
be.
Oh,
and
this
is
something
that
I
think
was
an
issue
that
that
Marcel
was
gonna
actually
start
looking
into.
A
Is
that
this
actually
tells
me
the
the
file,
but
it
doesn't
actually
tell
me
the
real
directory
that
it
actually
is
dealing
with
here,
so
we're
actually,
where
we
missed
a
lot
of
some
of
the
contexts
for
debugging
here.
But
what
we
can
look
at
is
service
alert
manager,
metadata
labels
component,
so
I
think
that
that's
probably
under
alert
manager
here
cube
deck.
You
metadata
labels
component,
we
don't
have
a
component
label
here,
but
you
can
see
here.
A
We
said
you
must
have
a
component
label,
that's
of
type
string,
but
here
we
don't,
and
so
now
what
we've
said
is
just
even
starting
out.
We've
said
every
service:
every
deployment
in
our
entire
hierarchy
must
have
a
label
on
it
called
components.
We're
not
saying
what
that
is,
but
it
must
exist.
We
found
the
places
where
it
doesn't
exist,
so
we're
already
actually
specifying
policy
and
finding
bugs
in
our
configuration
where
we
didn't
have
one
of
these
things,
and
so
now
we
can
go
through
and
we
can
start
using
some
of
the.
A
Okay
and
we're
gonna
do
the
same
thing
here.
So
we're
introducing
essentially
a
new
type
coming
on
here
and
then
we're
saying
component
is
of
type
string
all
right.
So
this
is
essentially
we're
creating
a
new
sort
of
type
of
def
in
this
language,
not
exactly
I'm,
not
the
language
nerd
here
and
now.
What
we're
actually
doing
is
and
there's
some
Voodoo
here,
I'll
explain,
sort
of
what's
going
on
here.
A
Doing
is
it's
saying
direct
list.
Each
of
the
directories
under
services
feed
that,
to
said,
we're
set
is
actually
going
through
and
removing
blank
lines
feed
that
to
X
argh,
where
were
the
the
interpolation
thing,
is
called
der
executes
this,
this
shell
command,
where
we
CD
into
the
directory
and
we're
going
to
create
a
queue
file
under
that
thing.
That
essentially
just
has
the
directory
as
the
components
specializes
at
per
directory
and
then
CD
back
out.
So
let's
go
ahead
and
run
this
and
I'll
show
you
what
this
does
so
now.
What
this
does
is.
A
This
is
some
some
voodoo
magic
here
going
on
for,
but
if
we
look
under
services,
let's
look
under
front
end.
We
now
have
this
new
file
called
Q
cube
Q,
and
this
says
the
component
for
this
directory
is
front-end
similarly
down
here
for
infra
or
no,
which
is
the
the
monitoring
one.
We
have
one
that
says
the
not
for
alert
manager
here.
The
component
here
is
mom,
okay,
so
that's
great.
A
Now
the
interesting
thing
here
is
that
there's
places
where,
if
we
look
at
front
end,
this
thing
says
component
is
front
end,
but
then,
when
we
actually
dig
into
cue,
this
says
that
component
is
front
end
also,
so
we
actually
say
so
Marcel
says
working
on
a
native
diff,
okay.
So
what
we've
seen
here
is
that
there's
duplication
now
right,
because
we
actually
specify
the
component
in
the
root
directory
and
then
the
intermediate
root
directory
and
we're
also
specifying
it
on
every
single
thing,
same
thing
with
domain
prod.
A
So
there's
a
lot
of
sort
of
repetition
going
on
here,
but
okay.
So
what
we're
still
happy
with
this,
so
we're
gonna,
actually
sort
of
like
make
this
be
our
new
baseline
snapshot,
and
so
now
we
can
actually
call
cue
trim.
So,
let's,
okay,
so
we're
gonna,
see
if
our
stuff
sort
of
lines
up
here.
What
this
says
is
that
we
have
eighteen,
like
almost
nineteen
hundred
lines
of
config,
we
can
dog
call
cube,
trim
and
then
do
this
again
and
we're
down
to
thirteen
hundred
and
twenty
thirteen.
A
Twenty-Two
I
didn't
get
the
exact
same
numbers
here,
so
this
is
a
little
out
of
date,
but
that's
okay.
So
now
what
trim
did
is
this
is
a
refactoring
thing.
It
says:
hey
if
a
value
is
nothing
more
than
restating
of
one
of
the
defaults
just
go
ahead
and
actually
trim
that
out,
and
so
what
we
find
here
is
now
our
service.
A
Just
has
the
port
specified
all
the
labels,
all
that
stuff
is
just
using
the
defaults
that
are
specified
both
here
in
component
is
front
end,
but
then
also
in
the
top-level
schema
file
here,
and
so
the
only
input
into
the
services
is
the
ID
plus
the
actual
ports
that
were
specified,
which
is
really
really
cool.
So
we've
already
actually
seen
a
significant
simplification
in
terms
of
the
amount
of
boilerplate
that
we
have
going
on,
but
you
can
take.
So
this
is
part
of
that
iterative
process
of
finding
commonalities
across
your
configs.
A
Extracting
those
commonalities
into
these
schema
slash
default
files
and
then
turning
the
crank
and
using
cue
trim
to
be
able
to
to
be
able
to
go
through
and
trim
this
stuff
down.
Okay,
so
now
and
then
we
can
actually
form
that
nothing,
nothing
changed,
save
that
into
a
snapshot
and
do
a
diff
and
oh
man.
A
B
A
Good,
okay,
so
now
we're
gonna
do
better,
and
so
at
the
top
level
template
we're
gonna
actually
go
through
and
add
some
stuff
to
it,
and
this
is
going
to
be
expanding
this
to
other
types
of
objects,
so
we'll
go
through
we're
going
to
add
a
bunch
of
stuff
at
the
end
here,
all
right.
So
now,
what
we're
saying
here
is
a
daemon
set.
A
Is
this
generic
underscore
suspect
object
along
with
the
API
version,
the
kind
and
setting
the
name
equal
to
that
ID
super
easy
they're,
similar
with
stateful
set
deployment,
but
we're
gonna
actually
say
that.
Well,
the
deployment
has
a
default
number
of
replicas.
This
is
one
of
the
niceties
of
Q
over
something
like
yeah,
Mille
or
json.
Is
that
you
can
essentially
nest
these
things
a
little
bit
and
save
yourself.
Some
lines.
A
A
A
So
that's
actually
pretty
cool,
so
we
haven't
removed
the
old
definition
of
deployment.
So
there's
a
little
bit
of
duplicate
there.
We
can
actually
go
through
and
unify.
Those
things
it
says
left
is
an
exercise
to
the
reader.
So
let's
actually
go
through
and
do
this
so
we're
gonna
say
a
service
as
a
is
not
well
so
spec
has
a
template,
so
this
thing
doesn't
have
a
template,
so
a
service
is
not
going
be
it
but
deployment
actually
has
a
template,
and
so
we
can
do
Oh.
A
A
A
A
B
A
Okay,
so
we
got
that
going
on
and
then
now
this
is
where
things
get
a
little
bit
more
interesting
and
and
and
to
be
honest,
I'm,
not
saying
I'm,
not
sure,
I,
fully
croc
what's
actually
going
on
here,
but
let's
try
and
actually
decode
what's
happening
here
so
now.
What
we're
actually
saying
here
is
that.
A
We're
going
to
have
this
new
type
called
spec,
which
is
essentially
the
the
sort
of
port
stuff
and
we're
going
to
say
that
if
something
actually
conforms
to
this,
then
it
has
true
or
false
as
an
export
on
ports
defaulting
to
true
and
then
we're
going
to
go
through
for
each
of
the
deployments.
Damon
set
and
stateful
sets
we're
going
to
go
through
and
actually
define
a
new
thing,
which
is
service,
which
is
the
name
of
these
particular
things.
A
Inside
of
these
these
things
and
then
for
a
value,
we're
gonna,
pull
out
the
labels,
we're
going
to
om
we're
gonna,
create
a
new
service
out
of
deployment
demon
set
and
stateful
set.
So
this
is
actually
really
interesting.
What
we're
saying
is
that
for
every
single
one
of
these
we
want
to
create
a
buddy
service
and
so
and
then
and
that's
going
to
share
the
labels
from
the
original
deployment
daemon
set
our
stateful
set
and
and
it's
going
to
go
through
and.
A
Specify
ports
on
the
service
as
long
as
those
ports
don't
have
underscore
export
false
on
them.
So
this
means
we'll
automatically
export
every
port
from
a
deployment
daemon
setter.
Stateful
set
regardless,
doesn't
matter
we're
going
to
go
ahead
and
do
that
unless
there's
a
special
tag
on
those
things
saying.
Please
don't
export
me
so.
A
Okay,
so
talking
about
a
lot
of
the
stuff
going
on
here.
This
is
not
something
that
we're
gonna
actually
dig
into
yet,
and
then
we're
going
to
go
through
we're
going
to
do
some
quick
patches
here,
where
we
don't
want
to
export
some
of
these
things.
So
we're
going
to
set
some
so
for
infra
events,
infra
tasks
in
infra
watcher.
We
don't
want
to
export
any
of
the
ports
so
we'll
set
that
will
change
the
default
for
those
things
we'll
go
through
and
do
that.
A
We're
down
to
12
31,
so
we've
actually
lost
quite
a
few
lines
and
what
we
ended
up
losing
was
if
we
go
back
here.
I
don't
have
service
anymore
in
this
bartender,
sir.
This
bartender
file.
So
we've
gone
from
this,
where
I
have
to
specify
both
the
service
and
deployment.
But
we've
actually
said
hey
for
every
deployment
also
create
a
service
and
all
the
information
we
need
for
the
service
is
encoded
here,
because
we
have
this
container
port
thing.
It
automatically
knows
to
be
able
to
expose
all
of
that.
A
A
A
We
can
go
through
and
start
having
some
other
defaults
that
we're
gonna
actually
put
in
our
in
our
in
our
directory
so
like.
If
we
look
at
front-end,
we're
gonna,
say
everything
under
frontend.
Has
this
Prometheus
scrape
annotation
right?
So
that's
a
lot
of
boiler
boiler
plate
that
we're
actually
seeing
across
this
stuff,
and
some
of
some
of
them
were
missing
so
like
this
one
has
the
port
that
it
should
scrape,
and
this
one
just
says,
scrape
equals
true
but
forgets
to
actually
list
the
port.
A
So
what
we're
gonna
do
is
we're
going
to
come
in
to
the
Q
the
Q
file
at
that
root
of
the
front
and
we're
gonna
say
well.
Every
deployment
needs
these
two
annotations
and
the
container
port
is
7080
unless
you
specify
something
different,
but
here
we're
actually
saying
well
actually,
instead
of
repeating
that
thing
just
index
into
the
first
port
and
assume
that
that's
the
one
that
you
want
to
scrape
off
of.
So
that's
actually
pretty
cool.
A
So
there's
a
there's
like
a
lot
of
boiler
plates
been
removed
as
we've
gone
through,
and
then
we
can
do
similar
stuff
like
if
we
look
in
in
the
kitchen,
we
can
actually
see
like
dishwasher.
This
thing
still
has
a
bunch
of
stuff
here,
including
things
like
liveness,
probes
and
stuff
like
that,
and
so
we
can.
You
know
if
you
know
this
well,
so
that
one's
like
debug
health.
We
have
a
standard
across
all
of
our
things
in
this
component.
A
A
And
now
we're
down
under
a
thousand
nine
hundred
and
fifty,
so
this
is
pretty
cool
that
we
can
actually
find
all
this
commonality
here
now,
if
we
look
at
dishwasher
queue,
there's
still
a
lot
here,
but
you
can
see
like
oh,
maybe
I
want
to
have
a
standard.
Config
map
mapped
into
all
my
services.
That's
the
type
of
thing
that
you
can
actually
go
ahead
and
put
into
that
boiler.
Plate.
A
Does
this
mean
it
gets
merged
with
other
stuff?
That's
already
there
I'm
wondering
one
of
the
things
as
I
read
this
Marcel.
Is
there
an
idea
of
a
merge
key?
Is
that
something
that
you've
built
in
here
to
be
able
to
actually
deal
with
the
fact
that
we
have
that
says
that
there
may
be
more
entries?
Okay?
So,
let's
go
so
we
can
go
ahead
and
do
that
and
and
then
we're
we're
gonna
do
for
sous
chef.
We're
gonna
actually
go
through
and
say
a
sous
chef
doesn't
have
discs,
so
we
can
do
that
here.
A
A
A
A
There's
this
way
that
you
can
extend
queue
with
sort
of,
but
it's
like
the
CLI
thing
that
you
can
start
dumping
stuff
into
yeah,
mall
and
encoding
things.
So
this
is
a
way
to
extend
queue
so
that
you
can
essentially
based
on
that
structure,
generate
a
bunch
of
llamó
files.
That's
pretty
cool,
so
you
can
create
the
service
bartender,
breads,
Spach,
you're,
blah
blah
blah
very
cool
stuff
there.
So
it's
not
what
I
like
about
this
is.
A
This
looks
like
you're
writing
kind
of
go
to
some
degree,
but
this
is
all
actually
using
cue
to
extend
cue,
which
I
think
is
is
pretty
darn
cool
and
there
are
places
where
you're
essentially
exec
running,
where
you
can
actually
shell
out
on
these
things.
But
a
lot
of
the
stuff
can
be
do
with
that
can
be
done
without
leaving
leaving
cue
and
then
the
last
thing
that
I
think
is
really
interesting.
Here
is
we
can
and
I
have
already
have
go.
I
already
have
flora,
Nettie's
downloaded
or
actually
no
I.
B
A
Here
to
make
sure
that
this,
so
one
of
the
the
integrations
that
queue
has
is
the
ability
to
understand
the
way
in
kubernetes
we
encode
schemas
in
kubernetes
definitions
and
go
definitions,
its
able
to
actually
take
those
things
understand.
What's
going
on
and
generate
schema
for
them,
which
is
actually
pretty
darn
cool,
and
if
I'm
downloading
this,
hopefully
this
will
actually
download
somewhat
fast.
A
A
That's
all
generated
and
there's
some
advanced
sort
of
stuff
going
on
here,
like
what
does
the
like
at
go,
mean
I,
don't
know
so
there's
some
advanced
stuff
here,
but
the
idea
here
is
that
is
that
schemas
can
be
written
by
hand
like
we
did
in
that
example.
But
they
can
also
actually
be
extracted
from
other
sources,
whether
that
be
a
proto
def,
whether
that
be
go
source
code
or
whether
that
be
things
like.
Oh
so,.
A
A
This
is
a
mistake
that
I
make
all
the
time
is:
I'll
actually
be
specifying
a
label
or
an
annotation.
Those
things
are
actually
specified
as
string
to
string,
but
in
the
animal.
Sometimes
you
want
to
put
a
number
in
there
and
you
forgot
that
forget
to
actually
put
the
quotes
around
it,
and
so
this
helps
you
catch
that
because
it
actually
said.
Oh
look,
services,
bartender,
spec,
select,
phoo,
conflicting
values,
one
two
three
and
string
and
says
one:
two:
three
is
not
a
type
of
string.
A
This
string
actually
comes
from
the
generated
schema
from
the
actual
go
code,
and
so
this
is
actually-
and
this
is
I-
think
that
the
interesting
sort
of
take
that
cube
brings
all
together
is
that
it's
fundamentally
focused
on
creating
not
just
reducing
boilerplate
but
also
creating
things
that
we
know
are
going
to
be
complying
with
a
particular
schema,
and
so
that
schema
awareness
is
a
really
really
really
interesting
property
of
cue
that
I,
really
like
and
so
yeah
so
now
I
can
go
through
and
I'm.
Like,
oh
I
made
a
mistake.
A
Let
me
go
through
and
do
one
two
three
now
look
at
that
boom,
no
problem,
so
it
actually
helped
me
find
that
way
before.
I
try
to
apply
this
to
my
kubernetes
cluster,
and
so
these
things
can
be
generated.
But
then
you
can
augment
them
with
your
own
constraints.
Where
you
say:
hey
kubernetes
is
crazy.
I
want
to
actually
lock
things
down,
even
more.
You
can
go
ahead
and
do
that
so
I
think
with
that
I
think,
there's,
there's
more
here!
I
haven't
made
it
through
all
of
this
there's
more.
A
A
I
think
for
when
we
look
at
configuration
language
as
part
of
the
challenge
here
is
that
we
want
the
simple
things
to
still
feel
simple
and
we
want
people
to
be
able
to
ease
their
way
into
using
this
configuration
languages,
and
so
I
think
Q
is,
is
doing
a
decent
job
of
sort
of
surfing
that
edge
with
providing
abilities
to
import
things
and
then,
as
you
actually
go
through
and
start
extracting
the
the
boilerplate,
it's
not
totally
alien.
Looking,
you
can
start
to
reason
about
it.
A
Cube
that
Q
I,
okay,
oh,
is
this
the
top
of
yes,
this
is
a
top
level,
one
I
kind
of
can
sort
of
Intuit.
What's
going
on
here,
where
I'm
saying
a
service
where
there's
a
star
here,
I
see
these
things
lining
up,
it
doesn't
feel
as
alien
as
some
of
the
other
sort
of
configure
languages
actually
actually
start
pulling
this
stuff
out,
and
so
I
do
like
that.
A
One
of
the
things
that
I
think
would
be
super
useful
for
Q
and
Marcel.
Here's
a
suggestion
for
you.
This
was
something
that
was
built
over
time
inside
of
Google
for
bcl
and
GCL
is
that
there
was
actually
a
web
tool
that
would
actually
show
you
the
fully
final
rendered
version
of
your
stuff.
But
then
you
could
actually
go
through
and
say:
hey.
Where
did
this
value
come
from
right?
I
said,
like
I,
see
this
value
I
see
this
and
be
able
to
actually
trace
back
sort
of.
A
A
Sorry,
I
did
that
thing
again
where
it's
like
I
didn't
switch
back
to
my
screen
when
I
was
actually
talking
about
stuff,
but
I
was
looking
at
the
queue
thing
here
and
saying
that
as
I
look
at
this,
this
is
not
totally
crazy
in
terms
of
stuff,
but
I
do
see
like
these
types
of
constructs
will
look
alien
from
the
outside
the
double
colon
there's.
Another
thing
that
we
didn't
get
to,
which
is
question
colon,
which
means
that
it's
an
optional
value,
so
those
types
of
things
so
I'm
thinking,
maybe
a
tool
that
that
helps.
A
You
see
the
final
rendered
form
but
then
start
to
introspect,
where
things
are
I
think
another
interesting
tool
would
be
to
find
factorization
possibilities
like
hey
everything
in
this
directory
looks
very
similar.
Do
you
want
me
to
actually
do
this
thing
or
even
it's
like
hey
everything
in
this
directory
looks
the
same,
except
this
thing
looks
like
you
might
have
forgotten
some
stuff.
A
So
in
some
ways
you
know
when
you're
Excel,
when
you
do
like
a
fill,
and
it's
like
you,
do
one
two,
three
four
five
and
then
you
accidentally
repeat
3
2
times
Excel
will
actually
put
a
thing
there
saying
hey.
This
looks
out
of
order,
I
expected
to
see
these
things
lining
up,
but
they're
not
lining
up
having
some
tools
that
would
help
you
refactor
and
drive.
This
sort
of
refactoring
loop
might
be
really
interesting.
Also
so
so
there
are
some
interesting
ideas,
but
I
think
what
Q
has
right
now
is
super
super
interesting,
I.
A
Definitely
I'd,
love
to
see
it'd,
be
interesting
to
my
mind,
to
explore
what
this
would
look
like.
As
we
start,
you
know
like,
like
we
talked
about
earlier,
that
thing
that
Pinterest
did
where
they're
essentially
creating
their
own
operators
to
be
able
to
take
things
and
actually
specialize
them
and
I'm
wondering
like
what
would
it
look
like
to
make
a
kubernetes
operator
out
of
queue
where
you
could
use
queue
as
the
main
programming
language
behind
your
operator
for
doing
this
type
of
translation?
A
And
you
know,
can
we
use
annotations
to
be
able
to
relate
stuff
back?
What
happens
when
you
have
errors,
so
I
think
that
would
be
really
an
interesting
thing
to
explore
and
I
think
you
know,
as
we
look
at
making
operators
easier
to
write
in
general
leveraging
stuff
like
queue
as
part
of
it.
It
reminds
me
in
some
ways
of
our
a
little
bit
of
google
ism
here.
A
Is
that
the
way
that
MapReduce
worked
inside
of
Google
and
my
understanding
is
they're
not
using
MapReduce
anymore,
but
the
way
that
MapReduce
works
inside
of
Google
is
that
you
would
start
up
one
job
on
Borg
and
then
that
job
would
start
up
all
the
workers
that
needed
to
do
run
the
MapReduce
and
then
shut
down.
Those
workers,
and
so
in
some
ways,
MapReduce
inside
of
Borg,
was
very
much
in
the
operator
pattern.
It
didn't
have
a
CR
D.
It
actually
had
its
own
config.
A
You
launched
something
that
launches
other
things
and
what
happened
is
BC
L
ended
up
being
embedded
into
the
MapReduce
controller
sort
of
that
seeds
process
that
you
started
and
got
evaluated
at
runtime,
but
it
was
always
a
little
bit
messy
in
terms
of
being
able
to
do
that
stuff,
but
I
think
we
already
see
these
echoes
of
controllers
in
the
way
that
MapReduce
worked
at
Google,
and
this
idea
of,
like
hey
I,
don't
want
to
be
talking
raw
bore
API
from
within
my
control.
I
want
to
be
using
a
higher
levels.
A
Toolset
like
Q
to
be
able
to
do
that.
I
think
we're
going
to
see
that
pattern.
Repeat
as
we
look
to
create
controllers,
so
that's
actually
I
think
pretty
exciting
all
right.
Well,
that's
it!
Thank
you,
everybody
for
joining
me.
It's
2:30
we've
been
going
for
about
an
hour
and
a
half
I'm
excited
about
Q
I.