►
From YouTube: TGI Kubernetes 141: CDK8s
Description
Show notes up at https://github.com/vmware-tanzu/tgik/blob/master/episodes/141/README.md
- 00:00:09 - Welcome to TGIK!
- 00:04:28 - Week in Review
- 00:18:56 - Intro to CDK8s
- 00:26:34 - Installing CDK8s
- 00:31:12 - `cdk8s init`
- 00:37:59 - First program and run
- 00:46:04 - Creating reusable components
- 00:56:38 - cdk8s+
- 00:59:34 - Sidebar: language preferences and ops vs. dev
- 01:01:04 - Return to cdk8s+
- 01:14:49 - CRDs
- 01:21:05 - Wrapping up
Come hang out with Joe 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 going to explore CDK8s (https://cdk8s.io/). This is the Cloud Development Kit for Kubernetes made by our friends over at AWS. It is a set of libraries (primarily typescript) for generating Kubernetes config/yaml. Joe doesn't know typescript so this should be fun...
A
A
A
A
Well,
I
was
hoping
that
you
could
tell
me
where
I'm
screwing
up,
but
we'll
figure
it
out
together,
marco
from
italy.
Okay,
I
got
I
you
know
this
is
so
much
fun
for
me
to
see
everybody
just
huge
hello.
I
want
to
do
a
quick
shout
out
and
thank
you
to
paul
serzowski,
who
I'm
sure,
I'm
bitching
your
name
paul
who's
been
helping
with
a
lot
of
the
pre-work
making
sure
that
we're
set
putting
in
some
of
the
urls
and
and
checking
on
the
av
and
all
that.
A
So
why
don't
we
go
ahead
and
jump
in
and
start
going
through?
What's
happening,
oh
maddie,
good,
to
see
you,
let
me
start
going
through
some
of
the
some
of
the
things
we
can
review
and
if
you
all
have
ideas
on
so
so
what
we
can
do
is
tgik
dot,
io,
slash
notes,
I'm
putting
the
link
in
here.
I
meant
to
sort
of
figure
out
a
way
to
do
it
with
obs,
but
I
I
didn't
have
enough
time
to
fight
with
obs
to
get
that
link
up
there.
A
That
actually
is
sort
of
crowdsourced
notes,
and
so
that's
what
I'm
actually
that's
hackmd
awesome
service.
That's
what
I'm
actually
projecting
right
now
here
so
yeah,
so
core
kubernetes!
Not
a
lot
has
happened
since
last
tgik.
I
think
everybody
really
just
sort
of
wound
down
over
the
last
couple
of
weeks
of
the
year
and
you
know
2021
started
off
with
a
bang.
A
I
don't
know
if
anybody's
had
their
mind
on
kubernetes,
really,
to
be
honest,
hey
tiffany,
good,
to
see
you,
but,
like
paul
pulled
out
there,
some
some
interesting.
Oh
we
got
we
lost,
so
some
of
the
things
didn't
autocomplete
here,
I'm
not
sure
what
happened
there,
but
we
we
have
some
good
links
here
in
terms
of
like.
Why
did
that
not
do
its
thing?
Ht!
Oh,
you
know
what
it's
reversed.
A
We
got
some
good
links
here
in
terms
of
a
set
of
blog
posts
of
some
of
the
features
that
actually
came
with
1.20,
and
so
I
think
this
is
a
little
bit
of
sort
of
completing
the,
and
so
let's
go
through
these
real
quick.
I
mean
these
are
kind
of
like
you
know
we're
getting
into
the
weeds
here.
It's
I
think
it's
really
interesting
to
see.
This
is
the
type
of
things
that
we're
doing.
This
is
really
like,
for
example,
when
a
csi
driver
needs
to
mount
credentials.
A
A
So
that's
one
talking
about
like
using
different
apis
and
different
ways
to
do
this.
Third-
and
this
is
mostly
for
like
how
do
you
go
through
and
have
a
csi
driver-
that's
actually
putting
credentials
not
for
kubernetes,
but
for
other
things
into
a
volume,
but
have
it
actually
use
the
the
credentials
of
that
particular
pod
to
be
able
to
do
it,
antonia
good
to
see
you,
and
so
so
this
is
really.
This
is
interesting.
A
Third-Party
device
metrics
reaches
ga,
and
I
think
this
is
interesting
from
sort
of
a
a
larger
arc.
I
think
by
and
large
kubernetes
is
a
whole
bunch
of
things
right,
but
like
the
the
the
core
of
it,
for
most
users
is
around
containers
and
how
do
you
launch
and
monitor
containers
and-
and
you
know
when
we
think
about
containers-
the
big
footprint
that
we
think
about
is
really
you
know.
Compute,
storage
and
networking
and
as
you
look
across
what
kubernetes
does
so
much
of
what
it's
doing
is
really
about.
A
A
But
you
know
when
we
think
about
the
the
sort
of
like
the
resources
on
a
machine.
We
generally
think
ram
and
cpu
usage.
But
you
know
computers
are
more
complicated
than
that
and
we're
starting
to
see
things
like
gpus,
and
this
is
why
nvidia
ends
up
being
sort
of
coming
into
the
picture
here
being
one
of
those
things
where
it's
like.
A
We
have
special
machine
learning
things
like
tpus,
there's
fpgas,
there's
gonna,
be
you
know
over
time
more
and
more
special
purpose:
hardware
that
we're
going
to
want
to
expose
through
kubernetes,
and
so
I'm
seeing
this
being
done
in
a
generic
way
versus
just
hard-coding.
Gpus
is
really
interesting
to
me
very
cool,
and
then
this
is
a
granular
control
of
volume.
A
Permission
changes
I
I
haven't
had
a
chance
to
really
read
through
this,
but
the
idea
here
is
that
when
you
mount
a
volume,
how
do
you
actually
deal
with
mapping
user
ids
and
group
ids
into
into
linux?
And
so
that's
really
cool?
And
so
you
know
again.
This
is
one
of
those
things
where
you
know
we.
We
have
this
world
that
the
colonel
knows
and
we
have
the
world
inside
containers
and
just
really
dialing
down
all
the
different
configuration
metrics
that
we
need
across
these
things,
all
right
and
then
larger
ecosystem.
A
Kubernetes
image
policy
web
hook
explained,
and
so
this
is.
This
is
essentially
starting
to
look
at
how
you
can
actually
start
implementing
image
policies
using
a
web
hook
to
be
able
to
actually
do
that
and
so
using
oppa
and
and
so
actually,
it's
replacing
the
the
image
policy
web
hook
with
a
validating
emission
web
hook.
A
But
all
the
pieces
are
there.
You
know
and
there's
there's
multiple
ways
to
skin
this
cat.
We
have
one
way
that
we
that
we're
working
through
it
using
opa
and
gatekeeper,
but
there
are
multiple
ways
to
do
that
and
you
don't
have
to
actually
go
with
a
sort
of
fully
formed
commercial
solution
to
be
able
to
implement
these
extensions
and
really
get
these
benefits
alex
good
to
see
you
from
north
california.
A
Now,
when
you
say
north
california,
this
is
something
that
always
confused
me,
because
there's
north
california,
which
is
truly
north
california,
and
then
there's
the
san
francisco
air
bay
area.
Whereas
if
you
look
at
california
it's
kind
of
in
the
middle,
but
central
california
means
a
central
valley
and
real
north
true
north
california
is
really
what
southern
oregon
I
don't
even
know,
but
it's
something
that
always
confused
me
that
san
francisco
was
northern
california
all
right.
A
A
Is
you
know,
I
don't
know
exactly
the
terms
that
people
are
going
to
be
using,
but
I
think
we're
going
to
call
it.
How
do
you
secure
the
supply
chain
and
the
supply
chain?
Is
this?
You
know
all
the
bits
and
pieces
that
actually
go
into
the
code,
that's
actually
running
on
your
machine,
and
so
it's
everything
from
the
source
code.
A
The
compilers
and
systems
used
to
build
that
how
it
gets
packaged
up
the
dependencies
that
go
into
those
packages
when
you're,
actually
writing
code,
if
you're,
using
java
or
javascript
or
what-have-you,
or
go
you're
pulling
in
dependencies
in
terms
of
libraries
and
then
you're
producing
those
images.
And
you
want
to
make
sure
that
the
things
that
you're
actually
running
are
the
things
that
you're
producing.
So
that's
the
entire
supply
chain.
A
And
so
this
started
with
things
like
you
know
the
the
node
system
where,
like
you
know,
you
can't
write
a
node
app
without
pulling
in
hundreds
of
dependencies.
That's
something
where
all
of
a
sudden
people
started
getting
really
paranoid
and
there
were
examples
of
bad
actors
taking
over
some
of
those
things.
A
And
I
think
kubernetes
is
not
immune
and
in
some
ways
makes
this
super
easy
to
ignore
and
that's
not
a
good
thing,
and
so
I
think
this
is
something
that
we're
going
to
be
seeing
over
time.
More
and
more
concentration
of
and
alex
says
sounds
like
a
tough
problem,
yeah,
okay,
so
so
that's
a
pun.
There
I'll
explain
that
for
y'all.
A
So
there
is
this
cncf
project
called
the
update
framework,
which
is
essentially
a
mechanism
of
how
you
actually
sign
images
to
make
sure
that
the
images
that
you're
running
are
exactly
what
you're
running,
depending
on
how
they
actually
get
moved
around.
But
supply
chain
goes
beyond
just
signing.
It's
really
about
being
able
to
understand
everything
that
goes
into
that.
So
there's
other
projects
in
the
cncf
like
in
toto
which
actually
help
to
to
track
everything
that
goes
in
there,
and
so
there's
a
really
a
lot
of
really
interesting
work
going
on
in
this
space.
A
I
think-
and
it's
it's
one
of
those
things
where
there's
no
one
solution,
it's
about
a
defense
in
depth,
monitoring
all
of
this,
but
this
actually
is
like
you
know.
If
you
really
want
to
understand
the
the
the
the
sort
of
the
depth
and
the
complexity
of
like
oh
I'm,
just
installing
a
helm
chart,
this
goes
into
sort
of
the
excruciating
detail
of
actually
figuring
that
stuff
out
and
then
that
again
starts
playing
into
the
image
policies.
A
Where
now
you
might
say
like
wow,
I
don't
want
to
install
random
run
random
containers
instead,
maybe
I'll
have
essentially
an
allow
list
of
containers
or
containers
that
are
hosted
in
this
registry
or
this
prefix
or
signed
by
this
thing.
That's
the
type
of
thing
that
we
can
do
so.
The
super
micro
supply
chain
hack.
This
is
really
interesting,
is
the
that
you
know.
I
don't
know
if
that
was
real
or
not.
I
think
there
there
had.
A
All
right
so
I'll
keep
going,
we
can.
We
can
definitely
go
okay,
so
if
you
missed
it-
and
I
did
miss
it,
I
haven't
had
a
chance
to
watch
it.
There's
the
great
cncf
bake
off
and
here's
the
video
I
I
need
to
find
some
time
to
actually
go
back
and
watch
this,
but
like
this
was
really
great.
I
think
this
really
speaks
to
the
kubernetes
community
in
that
you
know
we're
at
this
time
where
everybody's
feeling
isolated,
they're
searching
for
community,
and
here
we
have
people
coming
together.
A
Having
essentially
a
you,
know,
virtual
bake
off
and
hanging
out
and
and
oh
look,
there's
some
nice
bourbon
going
on
there,
which
is
really
really
cool
to
see-
and
I
know
a
lot
of
work
went
into
the
into
the
community
celebration-
and
this
was
a
this
was
a
big
part
of
it.
So
if
you
want
to
get
a
sense
of
the
kubernetes
community,
that's
a
great
place
to
go.
A
Yeah
and
then
paul
was
running
a
lot
of
those
things
behind
the
scenes.
So
thanks
for
that,
paul
all
right,
neat
and
short
video,
the
chaos
engineering
kubernetes
using
cube
invaders.
So
so
this
is
really
fun
and
I
think
we've
seen
a
definitely
a
bunch
of
examples
of
people
building
games
with
the
kubernetes
api
in
the
back
end.
A
A
So
that
looks
really
interesting
cool
and
then
there's
the
what's
the
helm,
article
yeah
and
then
the
other
thing-
and
I
haven't
you
know
totally
like
read
everything
is
you
know
about
it
is
red
hat
acquiring
stack
rocks
is
obviously
some
of
the
news
of
the
week
too.
So
you
know
more
consolidation
and
acquisitions
in
this
space,
which
is
always
something
that's
happening,
yeah
cool,
all
right,
so
18
minutes
in
let's
go
ahead.
Oh
somebody
added
some
notes
here,
so
the
the
the
cloud
development
kit
for
kubernetes.
A
So
this
is
an
open
source
project
that
is
sponsored
and
driven
by.
Let
me
sort
yeah
by
our
friends
at
aws
and
I
believe
and
and
justin
correct
me
if
I'm
wrong,
that
you
know
cdk
there.
There
are
multiple
sort
of
there's
the
ada
aws
cloud
development
kit,
which
is
kind
of
a
similar
thing
for
for
for
managing
aws
stuff,
so
taking
the
same
ideas
with
aws
cdk
and
applying
those
things
to
kubernetes,
and
so
I
think
this
actually
ends
up
driving.
A
This
ends
up
driving
not
to
cloud
formation
right,
whereas
the
cdk
for
kubernetes
ends
up
drawing
kubernetes
manifest.
But
the
general
idea
is
that
you
know
we
we've
created
this
world
where,
where
to
run
any
of
these
systems
in
the
cloud,
whether
it
be
aws
or
kubernetes
or
you
know,
other
clouds,
it's
a
lot
of
configuration
and
that
configuration
starts
out
feeling
very
easy.
But
it
often
gets
out
of
control.
And
so
this
was
really
like.
A
You
know
when
we
think
about
wrangling
yaml
and
how
everybody
sort
of
hates
yaml,
and
I
have
a
a
a
talk
that
I
did
back
around
halloween
to
really
start
start
working
on
this.
To
talk
about
this
in
context
of
kubernetes,
you
know,
part
of
the
problem
is
yaml
itself.
There
are
definitely
like
tim's.
Tim
hawkin
had
an
example
of
a
change
in
the
way
that
yaml
handled
octal
numbers.
A
You
know-
and
you
know
in
in
terms
of
the
formatting
over
the
last
over
a
minor
release
of
the
ammo
spec,
so
yaml
itself
has
problems,
but
I
think
the
the
core
problem
here
is
that
there
are
a
lot
of
knobs
to
turn
and,
though,
and
keeping
track
of
which
knobs
you're
setting,
which
way
across
a
whole
bunch
of
different
areas,
is
a
hard
problem,
whether
you're
talking
about
cloud
formation
or
kubernetes,
or
what
have
you?
And
so
this
is
a
you
know,
a
a
you
know.
A
We
did
an
episode
on
that
cdk.
You
know
whether
it's
for
kubernetes
or
other
things
really
falls
into
the
camp
of
like
you
know
why
trying
to
make
make
this
look
like
dumb
data
just
go
ahead
and
let's
write
code
to
be
able
to
generate
it,
and
so
the
idea
is
that
what
we're
going
to
be
doing
is
we're
going
to
be
writing
programs
and
those
programs
will
generate
the
yaml,
and
so
it's
like
at
a
certain
level.
You
think
about
this
and
you're
like
this
is
crazy.
A
How
do
you
actually
define
and
turn
all
these
knobs,
but
instead
we
have
to
have
a
set
of
solutions,
and
you
have
to
pick
the
right
one
for
the
for
the
problem
space
that
you're
in,
and
so
this
is
on
the
end
of
the
more
sort
of
like
user,
real
programming
language.
Other
solutions
that
would
be
sort
of
in
the
same
class
would
be
something
like
paloomi,
which
I
think
we've
done.
An
episode
on
palumi,
also,
which
again,
is
this
idea
of?
Let's
use
real
languages
to
be
able
to
define
this
stuff
now.
A
One
of
the
interesting
things
as
I
was
digging
into
cdk
earlier,
is
that
it
doesn't
actually
deploy
things
all
it
does
well.
Pallumi
palomi
will
use
some
of
the
terraform
providers
under
the
covers,
but
but
it
also
knows
how
to
actually
talk,
kubernetes
explicitly
yeah,
so
so
the
so
there's
the
difference
between
the
cdk
for
kubernetes
and
polumi
is
that
the
cdk
for
kubernetes
just
produces
the
yaml.
A
And
so
that's
why
you
know
with
carvel
our
you
know
the
the
project
that
is
more
of
a
templating
solution.
Here,
it's
actually
split
into
a
set
of
sub
projects
where
one
of
those
things
is
the
producing
the
yaml
which
is
ytt
another
one
of
those
things
is
applying
the
yaml.
In
that
case
it's
cap,
but
now
we
can
actually
use
the
the
cdk
for
kubernetes.
Well,
how
do
you
guys
say
it?
Do
you
see
cd
cates?
A
A
Morteza
says,
with
cd
cd
cd
cates,
you
can
generate
code
that
generates
yaml,
okay,
so
rajasilan
now
I
got
to
learn
typescript
as
well.
Yeah
see
that's
one
of
the
sort
of
things.
If
you
know
typescript,
this
is
going
to
feel
very,
very
natural,
there's
also
python
and
java
support
here
we're
going
to
be
getting
into
that
a
little
bit
in
terms
of
how
to
actually
pick
between
these
things.
A
I
think
it's
really
like
you
know
it
depends
on
how
complex
a
configuration
you're
going
to
need
to
be
going
with,
and
again
that's,
I
think,
is
one
of
those
one
size
doesn't
fit
all
solutions
in
this
space,
hello,
nova,
good
to
see
you
we're
just
getting
into
things
hope
your
interview
went
well,
okay,
so
let's
go
through
and
get
started.
I
the
docs,
are,
are
pretty
good
here
and
I
started
going
through
it
a
little
bit
earlier.
A
A
Oh
you're
going
to
have
to
duck
out
on
us
again
for
more
interviews.
Okay,
so
there's
a
command
line
for
cdks
that
you
install
it's
a
node
based
command
line,
which
I
always
hate,
node
based
command
lines
because,
like
node,
like
I
don't
know,
I
always
have
a
semi-broken
node
in
configuration.
It
feels
like
there's
always
like
so
much
work,
just
like
getting
node
working,
but
there
you
go,
but
that's
just
the
tool
itself.
A
You
can
then
use
that
to
actually
generate
the
frameworks
for
typescript,
python
and
java,
and
if
you
start
looking
under
the
covers,
you
know
I
suspect
that
there's
room
to
extend
this
to
other
languages
and
other
types
of
things
later.
It's
called
node
for
a
reason.
Oh
very
funny,
folks
are
asking
when
you're
going
to
do
another
tgik
episode
nova.
We
got
to
have
you
on
at
some
point
again
yeah.
So
so
you
know
feedback
justin,
I
would
prefer
a
a.
I
would
prefer
a
static
binary.
A
A
A
Yeah
brew
does
a
good
job,
but
one
of
the
things
that
brew
had
me
do
is
I
the
first
time
I
ran
npm.
It's
like
update
your
npm.
I
did
that
and
then
it
gave
me
an
error
and
so
like.
I
was
swearing
at
at
node
at
that
point.
Okay,
so
we
had
the
cdk
command
line
installed
and
you
do
this
and
it
it
really
has
three
commands
here,
so
it
has
importing
stuff
and
we'll
get
into
what
importing
actually
means.
A
It
really
means
generate
the
library
in
the
framework,
from
the
schema
that
you're
working
with
there's
initiating
a
project
which
is
kind
of
like
a
you
know.
What
is
the
the
rails
command,
the
the
rails
command
to
say
like
start
me,
a
scaffold
project
and
then
there's
synth,
which
means
essentially
run
your
program
to
generate
the
ammo,
and
so
these
are
different
layers
and
different
things
that
we'll
be
going
through
here.
So
I
I'm
going
to
go
through.
I
think
you
know,
let's
we're
going
to
start
with
typescript.
A
I
don't
know
typescript
really
at
all,
so
I'm
going
to
be
fumbling
my
way
through
this
stuff
and
and
I
think
we
might
be
able
to
do
python.
I
didn't
bother
getting
a
jvm
all
set
up
for
this,
so
I
don't
think
we're
gonna
do
the
java
stuff,
but
we'll
start
with
at
least
typescript
and
then
we'll
we'll
go
for
there
from
there.
A
A
A
Okay,
makeder,
hello,
cd,
hello
and
then
we're
gonna
do
init
typescript
app.
So
if
we
do
cd,
kate's
init
help
you
can
see
and
there's
java
python
and
typescript
are
the
apps
that
we
can
be
that
we're
able
to
do
so.
We're
gonna
do
init
typescript
app
now
one
of
the
interesting
things
here,
and
this
is
just
sort
of
the
I
think
a
lot
of
this
is
inspired
by
rails.
Honestly,
is
this
idea
of
you
know
dry
right,
dry,
don't
repeat
yourself,
and
what
you're
going
to
see
is.
A
Is
that
what's
happening
here?
Is
this
is
doing
a
whole
bunch
of
stuff
and
it's
actually
importing
and
running
the
the
the
the
creating
the
the
kubernetes
target,
schemas
and
libraries,
it's
creating
some
scaffolding,
so
it's
essentially
creating
a
project
and
getting
it
all
set
up
for
us,
but
you're
like
well.
What
is
the
project
named?
A
And
so,
if
we
go
into
vs
code
here
and
look
at
so
here's
all
the
stuff
that
it
actually
created
for
us,
we
have
all
sorts
of
fascinating
things,
including
like
a
git,
ignore
you
know
a
help
file
that
tells
you
how
to
do
stuff.
So
this
is
like
this
starts
to
feel
like
a
heavy
duty
project
we
have
like
you
know
the
package.json
is
all
set
up
for
us
with
our
dependencies.
A
A
Well,
it's
like
hey,
I'm
gonna
assume
that
whatever
director
you're
in
is
the
name
of
the
project
or
the
the
thing
that
you're
actually
doing,
and
so
there's
a
lot
of
that
sort
of
like
you
know,
look
around
and
try
and
do
something
sensible
based
on
sort
of
what
you're
seeing
that's
going
on
here,
and
so
the
the
main
thing
that
we're
actually
got
going
on
here
is.
This
is
not.
A
Why
is
it
asking
me
about
python
instead
of
typescript,
weird,
okay,
I
don't
care,
go
away
is
essentially
what
this
is
is.
This
is
a
program
in
typescript
that
when
you
run
it
will
generate
some
yaml,
and
that's
really
everything
that's
going
on
here
and
we'll
start
to
to
dig
under
the
covers
here,
but
this
this
is
sort
of
like.
A
A
Cat
help,
what
we
can
do
is
we
can
do
npm,
run
watch
and
what
this
actually
says
is
is
anytime.
You
change
any
of
the
typescript
just
go
ahead
and
automatically
regenerate
the
the
javascript
behind
the
scenes
there,
and
so
this
is
one
of
those
things
that
we're
seeing
here.
Npm
run,
watch,
okay,
and
so
so
we've
gone
ahead
and
done
that
here's
what
we
got
we
did
the
cd
kate's
synth,
and
then
we
find
that
the
thing's
empty
right.
A
Oh,
I
have
this
thing
cut
off,
because
there
we
go.
What
that
ended
up
generating
was
imports
here,
which
these
are
the
libraries.
This
is
the
kubernetes
library
that
essentially
says
well,
here's
all
the
various
kubernetes
types
and
generating
essentially
a
bunch
of
of
strongly
typed.
You
know
structures
that
we
can
start
working
with
here,
and
so
this
is
a
huge
file
to
be
able
to
do
this,
and
this
is
not
an
unusual
pattern
in
these
types
of
tools.
A
If
you
look
at
the
way,
something
like
q
works,
which
is
another
specialized
language
for
templating
and
the
way
it
works
with
kubernetes
it'll
go
through
and
take
the
kubernetes
schema
and
then
generate
a
bunch
of
helper
libraries
and
structures
around
it.
The
original
case
on
it
did
this
also,
and
so
this
is
a
very
common
pattern
to
be
able
to
essentially
generate
true
language
helpers
in
an
automated
way,
based
on
the
schema
that
you're
actually
seeing
on
the
other
side.
A
So
let's
copy
and
paste
this
thing
here,
so
this
is
and
we'll
go
through
sort
of
what's
different
here
and
what's
going
on,
so
this
is
going
to
create
a
deployment
in
the
service
around
and
and
what
you're
seeing
here
is
that
this
is
we're
importing
from
that.
You
know
that
that
20
000
line
file,
we're
importing
cube
deployment,
cube
service
and
inter
string.
A
Okay,
so,
inter
string
is
there's
this
place-
and
this
is
it's
probably
a
bad
decision
in
the
original
kubernetes
api,
but
there's
some
places
in
the
yaml
where
it
can
either
be
a
string
or
it
can
be
an
integer
and
oftentimes.
We,
you
know
we
put
in
there
early
on
support
for
named
ports.
Where
you
could
say
I
want
to
connect
to
this
thing
on
this
port.
Well,
you
could
either
use
the
number
or
you
could
use
essentially
a
name.
That
is
a
logical
name.
A
If
we
go
to
the
definition
here-
and
this
is
in
that
case.ts-
what
you
can
see-
it's
just
it's
a
service
of
v1-
it
helps
to
actually
get
a
bunch
of
the
sort
of
block
and
tackle
stuff
filled
out
for
you,
and
so
here's
sort
of
that
definition
there,
and
so
so.
Here
we
have
a
service,
and
then
we
have
a
deployment
here
which
says:
okay,
we
have
two
replicas
we
have.
A
Let's
see,
label
is
there's
a
single
label
that
actually
gets
set
on
all
of
this
stuff,
and
so
this
is
one
of
the
things
where
we're
starting
to
see
some
real
javascript
come
out
is
that
we
have
the
structure
of
labels
app
equals.
You
know
app
goes
to
hello
kubernetes
and
instead
of
repeating
yourself
across
the
yaml.
This
is
one
of
the
things
that
makes
writing
kubernetes,
yaml,
really
annoying.
A
And
gone
ahead
and
done
this
also
right,
so
there
you
go,
and
so
you
can
see
how
like,
as
you
start
doing
this,
you
can
start
using
real
programming,
constructs
to
really
start
to
collapse
this
stuff
down
and
make
it
easier
to
use
yeah
rajesan.
I
I
think
you're
you're
exactly
right.
I
think
it's
one
of
these
things
where
typescript
and
javascript
like
these
things
are
universal
and
there
is
a
certain
assumption
of
familiarity
across
all
sorts
of
different
domains
and
there's
a
lot
to
learn
from
that
ecosystem.
A
So,
yes,
you
can
start
to
do
this,
but
like
one
of
the
things
that
I
think
you
know
you
should
come
away
here,
is
that,
like
this
doesn't
fundamentally
simplify
things,
there's
still
a
lot
of
knobs?
This
is
just
a
different
way
of
setting
those
knobs,
and
so
this
is
not.
You
know.
You
still
have
to
understand
that
a
deployment
has
a
template
that
is
different
from
the
selectors
and
that
the
raw
kubernetes
schema
is
still
exposed
to
you
here
for
good
or
ill,
at
least
with
the
level
of
the
cdks.
A
That
we're
dealing
with
right
now,
all
right,
so
we
go
ahead
and
we
have
this
and
what
we're
seeing
is
that
you
know
well
behind
the
scenes?
Theoretically,
okay,
so
it's
did
it
actually
compile.
So
I
think
it
compiled
yeah
okay.
So
now,
if
we
go
through
and
if
we
cat
main.js
this
is
the
this
is
essentially
the
javascript
version
of
that
typescript,
so
it
had
it
did
get
compiled.
A
So
now
what
we
can
do
is
now
we
have
the
javascript.
Now
we
actually
want
to
go
through
and
we
want
to
generate
the
the
the
yaml.
So
we
can
go
cd,
kates
and
then
synth
is
the
does
that
now,
if
I
do
dist
dot
hello,
dot,
yaml,
look
at
that
woo
hoo,
we
have
yaml,
so
it
all
get
compiled
down
and
there
we
go
well
leed,
suggesting
that
chef
used
to
do
ruby
101.
That
is
enough
to
use
chef.
I
guess
we
need
to
do.
A
A
I
don't
know
I'm
not
an
expert
in
openshift.
What
I
will
say
is
that
you
know
I
know
that
openshift
4
is
really
built
around
operators
and
crds,
and
so
there's
no
reason
to
think
that
this
one
wouldn't
work
against
those
also
so
yeah.
So
there
we
go
so
that
so
we're
up
and
running
I
mean,
and
this
thing
is
actually
like:
hey
there's
nothing
to
complain
about.
We
actually
have
things.
A
Have
things
working
now,
there's
a
couple
of
interesting
things
here
that
I
think
are
worth
looking
at
number
one
is
that
the
name
actually
has
this
hash
on
the
end
of
it,
and
I'm
not
sure
where
that
hash
came
from.
That's
really
interesting,
because
the
name
that
I
passed
here
justin's
am
I
going
to
go
yes,
so
I
want
to
talk
about
sort
of
like
now.
This
is
a
set
of
primitives
that
we
can
use
then
to
actually
do
higher
level
things,
including
the
cd
cdks
plus,
and
generating
your
own
sort
of,
like
wrappers.
A
A
A
A
A
So
there's
a
couple
of
things
that
I
have
questions
about,
and
I
think
you
know
just
notes
that
I
things
that
I
would
want
to
actually
dig
into
that.
I
don't
totally
understand
number
one.
Is
that,
like
okay,
we
gave
it
a
name.
Why
is
that
name
not
used?
Clearly,
there's
something
you
know
a
hash
or
something
being
added
to
the
end
of
it.
A
A
Ts
and
now
I'm
going
to
copy
and
paste
this
in
here,
I
think
the
name
needs
to
be
passed
in
the
option,
otherwise
generate
a
suffix
name.
Okay,
oh
I
see
so
the
id
ends
up
being
different
than
then
okay
gotcha.
So
I
see
so
the
name
ends
up
being
a
default.
So
let's
go
ahead
and
let's
let's
play
with
that
real
quick
just
to
be
able
to
see,
I
can
put
that
in
there,
but
now
what
you're
saying
is
that
if
I
do,
if
I
do
metadata.
A
A
Yeah,
okay,
there
you
go,
I
see
okay.
So
what
we're
passing
in
here
is
an
id
for
this
service
and
if
you
don't
actually
pass
in
a
name,
then
it'll
combine
essentially
the
name
of
the
chart,
which
is
the
the
the
larger
okay,
so
cdkh
uses
the
term
chart
to
actually
talk
about,
essentially
a
set
of
artifacts
that
generate
a
singular
yaml
file
that
is
different
than
a
helm
chart.
It
is
not
a
helm
chart,
but
it's
also
called
chart.
A
That's
a
little
confusing
gotcha
okay,
so
I
the
the
convention
is,
is
that
if
you
don't
actually
go
through
and
specify
the
the
name
there
explicitly,
the
default
is
constructed
based
on
sort
of
the
context,
that's
actually
being
passed
in.
Okay,
that
makes
a
ton
of
sense
cool
and
then
the
id
can
be
reference
downstream,
gotcha,
okay,
gotcha,
okay,
so
all
right!
So
now
we
actually
have
the
webservice.ts,
and
what
this
is
actually
doing
is.
A
This
is
actually
start
trying
to
take
this
thing
and
sort
of
like
put
it
into
a
reusable
component.
So
now
the
interface
here
is
going
to
be
a
heck
of
a
lot
easier.
We
have
the
image
number
of
replicas,
the
external
port
in
the
internal
port.
Now
this
makes
some
assumptions.
This
assumes
that
you
know
you're
not
doing
any
side
cars.
You
don't
need
to
to
modify
things
like
you
know
the
the
security
properties
of
the
thing
right,
like
whether
you
know
what
user
id
do
you
want
to
use
inside
of
it.
A
If
you're
running
this
non-root,
you
know
it
assumes
that
you're,
not
configuring
any
volumes
right.
So
there's
a
whole
bunch
of
assumptions
here,
because
it's
creating
a
super,
simple
interface,
which
is
great,
but
it's
also
hiding
a
lot
of
the
flexibility
of
underlying
kubernetes,
and
so
I
think
that's
a
lot
of
the
trade-offs
that
you'll
see
as
people
try
to
simplify
kubernetes
is
that
every
single
knob
is
there
for
a
reason,
and
if
you
try
and
hide
that
knob
you're
also,
then
narrowing
the
applicability
of
the
things
that
you
can
do
with
it.
A
A
So
that's
the
that's
the
set
of
nouns,
I
believe
at
least
that's
my
understanding
of
it.
Okay,
so
let's
go
through,
and
how
do
we
then
change
our
main
to
be
able
to
use
that
we'll
go
ahead
and
do
that?
And
here
we
have
we're
importing
web
service
from
lib
web
service
and
then
our
chart
we're
essentially
creating
two
ones
called
hello,
kubernetes
and
one's
called
ghost.
A
A
A
Welcome
back
nova
using
typescript
to
generate
yaml
is
kind
of
like
using
a
dirty
fork
to
eat
rotten
food.
We
need
to
convince
rob
pike
to
design
a
better
scripting
language.
Well,
john
funny,
you
should
mention
this
because
you
know
you
know.
Same
type
of
thing
happened
inside
of
gcp,
where
some
very,
very
smart
people
ended
up.
Creating
this
thing
called
deployment
manager,
which
was
essentially
using
languages
to
be
able
to
actually
generate
the
config
so
that
you
can
do
deployment.
So
this
idea
of
using
a
real
language
to
generate
the
config.
A
It's
not
something
that's
I
think,
is
going
to
go
and
go
away
anytime
soon
and
and
generating
a
new
language
has
a
really
high
bar.
I
think
often
times,
there's
a
huge
hump
to
be
able
to
get
over
it
and
make
it
useful
and
so
basing
it
on
something.
That's
widely
understood
like
javascript
or
python,
makes
a
ton
of
sense.
One
of
the
things
that
we
probably
won't
have
time
to
get
into
here
is
testability.
A
When
you
do
use
a
real
language
ecosystem,
you
get
the
tooling
you
get
auto
complete.
You
get
testing
all
the
other
stuff
that
actually
goes
along
with
it.
Inventing
something
new
to
solve
all
those
problems
from
scratch
is
really
really
hard.
If
you
are
looking
for
a
new
language
in
this
space
and
you're,
you
know
I
would
take
a
look
at
q,
which
is
really
really
interesting.
A
Cue
language,
but
is
gonna,
be
facing
some
of
the
the
the
similar
things
that
I
talked
about
where
it's
different
people
don't
understand
it,
it
doesn't
have
the
larger
ecosystem
around
it,
and
so
I
think
those
are
the
trade-offs
that
we
have
to
make
when
we
think
about
this
stuff,
so
yeah
so
chris.
The
way
that
it
works
is
that
you
write
typescript
typescript
then
gets
compiled
to
javascript,
and
then
you
run
the
javascript
to
generate
the
the
yaml
all
right.
A
But
I
won't
do
that
right
now,
because
I'll
start,
I
would
love
if
they
make
it
available
for
kotlin
too.
I
need
to
understand
kotlin.
Now
there
is
a
java
version
of
this,
and
I
don't
know
if
that
actually,
then
is
reusable
with
kotlin
or
you
can
mix
and
match
those
things.
I
need
to
learn
some
kotlin
at
some
point.
Add
that
to
my
list
for
sure.
A
I
don't
know
what
this
will.
Look
like
java
seem
much
more
verbose
than
ts
yeah.
So
one
of
the
problems
here
is,
I
think
you
know
these
types
of
situations
generating
yaml
structure
from
go
is
actually
pretty
painful
because
of
the
way
that
go
handles
types,
it's
not
as
freeform
and
lucy
goosey
as
something
like
python
or
javascript,
and
so
so
I
think
that
there's
definitely
for
generating
config.
A
A
All
right.
So
that
is,
I
think,
that's
the
core
example
that
leads
us
through
this
stuff.
Now
one
of
the
interesting
things
here
is,
you
know
the
and
and
and
this
echoes
some
of
the
work
that
we
did
early
on
with
k
sonnet
also,
but
clearly
we
picked
the
wrong
language
with
jsonnet
versus
something
like
json
I
mean
like
javascript.
A
A
The
other
half
of
this
is
this
thing
called
cd,
kate's
plus,
and
what
this
is
is.
This
is
a
essentially,
I
believe,
a
set
of
handwritten
wrappers
that
actually
start
to
create
a
friendlier
interface
to
the
raw
kubernetes,
and
so
it's
one
level
removed.
You
can
either
work
with
raw
kubernetes
and
typescript,
or
you
can
start
using
the
next
level
up
with
the
cdk
stuff
and
because
this
stuff
is
actually
going
through,
and
this
is
hand
tuned
and
written.
A
What
you'll
see
is
that
oh,
look
it's
only
available
in
python
and
javascript,
which
ends
up
being
interesting,
because
that
means
that,
like,
oh,
the
java
support
doesn't
do
this,
because
it's
not
automatically
generated
there's
a
human
sort
of
action
to
be
able
to
extend
these
things
and
actually
make
this
stuff
work.
But
this
is
a
pattern
that
we
see.
A
lot
is
that
you'll
have
automatically
generated
stuff
and
then
layered
on
top
of
that
you'll
have
things
that
are
human
generated
for
providing
sort
of
a
more
thoughtful
interface
higher
level
abstraction.
A
A
A
I
don't
know,
okay.
Well,
that's
not
what
we're
not
what
we're
digging
into,
but
in
any
case
so
there's
there's
the
cd
kate's
plus
stuff
that
we
can
actually
go
ahead
and
start
working
with
here
and
so
we'll
go
ahead
and
install
that,
because
it's
a
separate
library
and
let's
go
through
and
and
copy
and
paste
this
and
start
going
through
this
and
seeing
what
this
looks
like.
A
Here
so
sevy
is
saying
so
usually
there
is,
you
know
devops
who
cannot
write,
typescript
and
devs
that
are
not
interested
in
yamls
yeah.
This
is
interesting,
I
think
you
know
I
I
think
you're
not
wrong,
that
I
think
in
a
lot
of
traditional
organization
there.
The
folks
in
the
ops
roles
are,
you
know,
they'll,
do
a
little
bit
of
bash
or
power
script,
but
they
don't
really
go.
You
know,
they're,
not
super
comfortable,
oftentimes,
going
super
deep
into
say
the
javascript
world
or
or
maybe
python
is
more
accessible
there
and
oftentimes.
A
There's
then
development
teams
that
are
very
much
on
the
on
the
path
of
like
well.
I
don't
want
to
worry
about
that
deployment
stuff.
That's
somebody
else's
problems
and
I
think
that's
one
of
the
reasons
why
you
know
these
things
that
really
start
crossing
the
lines
find
an
audience
with.
You
know
essentially
newer
teams,
whether
it
be
a
startup
or
or
what
have
you,
but
often
struggle
to
actually
adapt
to
these
more
traditional
segmented
roles.
A
And
this
is
why
something
like
cloud
formation
or
terraform,
or
what
have
you,
is
actually
fairly
attractive
because
those
things
end
up
being
coding
without
the
coding.
It
doesn't
feel
like.
You
have
to
deal
with
all
the
block
and
tackle
of
actually
dealing
with
npm
and
javascript,
and
all
that
other
stuff.
A
Yeah,
so
I
do
think
that
that
that
it
is
interesting
to
actually
see
you
know
how
do
these
different
tools
apply
to
different
types
of
users
and
how
do
they
view
this
world?
Okay?
So
what
do
we
got
going
on
here?
So
we
create
a
new
cdk
dot,
app,
okay,
a
new
chart,
and
then
here's
k
plus
is
is,
is
the
k
cdks
plus,
and
this
is
for
17
for
1.17,
I
assume
is
what
it's
targeted
at
so
robert
says,
cdk's,
loops
and
conditions.
A
A
We
use
a
trick
with
config
map,
so
we're
going
to
do
config
map
app
data
ad
directory,
dur
name
app.
Oh
wow,
we're
actually
deploying
an
app
into
a
config
map.
We
create
a
volume
from
that
we're
creating
a
thing
and
then
we're
essentially
running
node.
I
don't
I
don't
know
what
I
think
about
this,
so
the
code
for
the
actual
app
is
showing
up
in
a
config
map.
That's
probably
not
a
good
idea,
because
there
are
limits
on
the
size
of
config
maps
and
at
some
point
you
will
probably
have
too
much.
A
But
it's
interesting.
This
is
an
interesting
hack
to
be
able
to
do
that.
Okay,
and
so
what
we're
actually
seeing
here
is
that
there's,
instead
of
having
to
actually
go
through
and
specify
deployment,
we're
using
the
k,
plus
deployment
and-
and
we
can
then
pass
in-
let's
see
so
we
have
we're
creating
a
config
map
and
a
volume.
A
The
deployment
and
then
we
can
talk
to
the
deployment
and
actually
build
it
up,
including
the
mounts
and
stuff
like
that,
so
that
ends
up
looking
really
really
interesting
there.
So
you
don't
have
to
actually
put
all
the
yaml
together
explicitly.
This
has
a
bunch
of
helpers
to
be
able
to
do
it
all
right,
I'm
going
to
catch
up
on
the
on
the
comments
here.
A
Okay,
justin
says:
cdk
has
a
parameters
var
equals
val,
but
it
doesn't
look
like
it's
available
in
cd
kate's
right
now.
Okay,
so
eventually
there
may
be
a
way
to
pass
parameters
into
your
program
when
you
do
the
synth.
But
that's
not
something
that's
supported
here.
So
when
you
write
one
of
these
things,
what
it
produces
is
what
it
produces
and
you're
never
going
to
actually
see
it
produce
something
different.
A
Terraform
for
each
sure
beats
count,
especially
when
you
use
a
lot
of
dynamic
blocks.
So
with
testing
with
this,
you
can
generate
the
manifest
and
then
just
write
assertions
against
that.
So
you
don't
have
to
apply
it.
I
have
a
kind
cluster
running,
but
I
don't
know
if
we're
actually
going
to
get
to
that
in
this
large
codebase
that
I've
seen
in
json
really
make
me
wish
that
this
was
a
go
and
typescript
yeah.
I
need
more,
go
all
right,
so
cool,
so
so
yeah.
A
A
A
Add
data
and
add
from
files.
This
actually
then
knows
how
to
use
the
javascript
program
to
be
able
to
read
stuff
and
actually
construct
the
config
map,
for
you
so
being
able
to
have
code
that
actually
can
like
do.
That
is
actually
really
interesting,
and
so
that's
a
great
example
of
this.
Okay,
so
boom
boom
boom
and
then
it
goes
through
and
it
does
expose
and
what
is
exposed
to
so.
This
actually
then
creates
a
service
around
it
with
type
equals
load.
Balancer.
A
A
A
A
A
A
A
A
A
A
A
A
And
then
here's
the
command
and
it's
mounting
the
config
map
as
a
volume
and
making
that
available
there
sweet
and
then
having
the
service
actually
point
to
it.
So
this
is,
you
know
this
is
a
fairly
complex
configuration
where
we
have
a
config
map
that
we're
then
mounting
in
and
then
we're
into
a
certain
place,
and
then
we
have
a
container
that's
using
that
config
map
and
then
we're
exposing
it
and
so
generating
the
config
map
from
stuff.
That's
actually
sitting
on
disk.
A
So
that's
a
relatively
complex
configuration-
and
you
know
I
like
reading
this.
You
know
this
looks
relatively
straightforward,
where
I'm
creating
the
config
map
with
my
source
code
and
then
I'm
going
through
and
I'm
then
creating
the
deployment.
I
especially
like
the
sort
of
the
mount
syntax
here,
because
essentially
what
we're
doing
is
two
things
is
that,
where
we're
we're
taking
this
volume
here
and
we're
mounting
it
into
this
container,
so
it's
a
container
thing.
A
A
Why
didn't
we
just
go
ahead
and
say:
hey
put
the
volume
directly
in
the
container?
Well,
that's
because
we
wanted
to
actually
make
room
for
the
case
where
you
have
the
same
volume
mounted
in
different
locations
across
multiple
containers
in
the
same
pot.
That's
a
relatively
rare
case,
but
people
have
to
sort
of
pay
the
cognitive
price
of
understanding
that,
even
if
they're
not
using
it,
whereas
I
think
when
you
have
an
interface
like
this,
I
really
like
how
it's
actually
going
through
and
saying.
A
Well,
here's
the
thing
mounted
into
this
thing
and
it
skips
all
that
sort
of
plumbing
and
referencing
that's
happening
under
the
covers
in
the
ammo.
So
that's
really
cool
joe.
I
thought
you
would
prefer
a
slew
of
bass
grips
to
auto,
generating
the
ammo.
This
would
be
a
nice
clean
solution
to
generate
manifest
in
a
ci
cd
pipeline.
I
I
think
that.
A
I'm
not
a
fan
of
writing
yaml
by
hand.
I
think
it's
actually
like.
I
think
it's
good
for
understanding
kubernetes
to
understand
what's
happening,
and
you
know
understanding,
pods
versus
deployments
and
how
these
things
are
threaded
together,
but
I
think
for
most
most
users
they're
doing
simpler
things.
They
don't
actually
need
to
be
able
to
do
that.
So
I'm
a
huge
fan
of
building
higher
level
toolkits
on
top
of
this
stuff,
so
that
you
can
actually
go
through
and
and
really
streamline
the
the
experience
here.
A
So
I
actually
think
there's
some
really
cool
stuff
here.
I
don't
know
if
I
would
do
expose
here.
I
would
probably
say
you
know
creating
the
the
the
load
balance
or
service
ingress
stuff.
I
would
have
that
be
a
separate
thing
that
you
then
attach
this
to,
but
you
know,
I
think
you
know
there's
different
ways
to
view
this
for
sure
nova
says
I
like
reading
yammer
a
lot
writing
yaml
can
be
hard
yeah.
I
agree
with
that.
A
I
think
I
think
yaml,
like
the
explicitness
of
yaml,
is
a
good
thing
like
there's
no
room
for
ambiguity,
but
that
makes
it
super
painful
to
be
able
to.
Actually,
you
know
write
to
so
that's,
okay.
So,
let's
see,
let's
do
one
more
thing
here
before
we
actually
call
it
a
day,
let's
go
through,
and
so
here's
the
examples
that
we
went
through.
So
there's
the
hello
kubernetes
there's
this
web
service
abstraction
that
I
think
you
know
we
and
they
have
like
yeah.
A
A
A
We
actually
have
a
a
similar
type
of
thing,
for
cd,
cakes
and
and
what
you
can
say
here
is
it's
saying:
okay,
I
want
to
import
kubernetes
at
version
1.17.,
here's
like
a
raw
sort
of
yaml
file
with
the
so
there's
a
syntax
here
where
you
can
actually
get
these
things
from
different
directions,
and
so
one
of
these
things
like
version.yaml,
is
a
simple
custom
resource
definition
that
doesn't
actually
have
a
schema
associated
with
it.
So
this
is
an
old-school
type
of
thing,
and
so
we
can
look
at.
A
A
It
has
the
group
version
kind,
it
has
props
and
that's
it
so
super
duper
simple,
whereas
I
think
you
know
we
can
get
into
more
complex
stuff
like
here's.
Mattermost
has
a
more
complex
thing
with
a
full
schema,
and
then
that
turns
into
this
and
what
you
can
see
is
now
there's
a
whole
bunch
of
help
in
terms
of
setting
the
schema
to
make
sure
that
you
get
type
safety
when
you're
actually
working
with
the
schema.
A
So
that's
really
interesting
to
actually
see
that
there
guillaume
says
I
have
a
lot
of
issue
importing
crds
to
have
the
full
code
generation
leader
must
have
an
open
api,
spec
declared,
so
not
all
crds
will
be
correctly
imported.
I
tried
with
tekton
and
it
didn't
generate
all
the
interfaces
yeah.
I
think
this
is
one
of
those
things
where
you
know
with
crds.
Only
with
the
v1
versions
of
crds
did
it
start
requiring
the
full
schema
for
it.
A
But,
like
there's
a
certain
question
of
like,
if
you
don't
have
the
schema,
what
are
you
going
to
do
right?
I
think
that's.
That's
kind
of
that's
kind
of
the
the
situation
that
we're
in,
but
I
really
like
I
mean
so
the
things
that
I
that
I
like
here
is.
I
do
like
that.
There's
an
explicit
sort
of
like
listing
of
here's,
all
the
things
that
you're
importing,
I'm
not
sure
how
I
feel
about
just
sort
of
downloading
random
stuff
off
the
internet
here,
but
I
guess
that
works.
A
I
mean
it's
up
to
you
to
make
sure
that
you
pick
a
stable
url,
that's
not
going
to
be
changing,
otherwise
you
can
get
some
really
weird
behavior
out
of
it
and
then
I
think
it
just
goes
to
show
that,
like
you
know,
this
idea
of
having
schemas
with
crds
really
starts
to
elevate
them
such
that
we
can
build
real
tooling
around
them.
That
is
just
like
the
built-in
kubernetes
objects,
so
that's
actually
cool
all
right.
So
we're
we're,
I
think,
we're
I'm
heading
to
the
end
here.
A
So
I'm
I'm
I'm
really.
I
think
this
stuff
is
cool.
The
things
that
I
really
like
about
it
is
that
it's
part
of
a
tool
chain
we're
just
generating
yaml
we're
not
applying
it,
and
so
this
actually
gives
you
a
lot
of
room
to
to
be
able
to
use
it
with
a
git
ops
flow
or
with
you
know,
you
know
other
tooling,
like
cap
to
be
able
to
deploy
it.
I
think
that's
really
cool
the
steve.
I
see
you
asking
about
the
shirt
I'll,
explain
the
shirt
in
a
second.
A
This
is
a
back
when
we
were
able
to
travel
through
airports
and
it
turned
into
one
of
my
favorite
shirts,
so
things
that
I
like
so
I
like
that.
I
think
one
of
the
things
that's
missing
is
parameterization
the
fact
that
there's
no
way
to
pass
in
command
line
arguments
to
this
thing.
I
think
you
know
you
may
want
to
have
something
along
the
lines
of
like.
Let's
say
that
you
want
to.
A
You
know,
deploy
something
to
10
different
clusters
and
you
may
want
to
actually
pass
in
some
of
the
different
parameters
for
some
of
the
different
clusters,
as
you
actually
generate
this,
so,
instead
of
being
able
to
script
that
from
the
outside,
you
then
have
to
actually
script
it
on
the
inside,
which
which
probably
creates
a
certain
level
of
impedance
mismatch
as
you're
trying
to
integrate
this
with
other
tool
chains.
So
that's
something
that
I'd
like,
I
think,
should.
Probably
I
would
look
to
improve,
I
think
in
general.
A
I
think
this
class
of
solution,
the
sort
of
the
cloud
development
kit
in
general,
it's
very
much
aimed
at
developers.
It
assumes
that
you're,
a
developer,
you're
comfortable
working
in
a
language
like
python
or
javascript
or
java
or
whatever,
and-
and
you
find
that
as
an
accelerator
as
a
booster,
I
think
that's
also
a
downside,
because
there's
a
whole
lot
of
folks
that
interact
with
kubernetes
as
operators
that
aren't
comfortable
actually
getting
involved
in
this
world,
and
it
turns
into
something
that's
super
super
intimidating.
A
So
I
think
you
know
we
want
to
make
kubernetes
easier
for
folks
to
use,
and
I
think
you
know
what
easy
means
is
actually
changes
depending
on
who
you
are
right,
like
so
some
folks
putting
a
real
programming
language
on
it
is
like.
Finally,
this
is
super
easy.
I
understand
what's
happening
here
for
other
folks.
This
will
actually
be
a
real
turn
off
because
they're
like,
oh
god,
now
like
I'm,
not
a
programmer.
How
do
I
actually
do
this?
Now?
A
You,
and
I
might
say,
oh
it's
not
that
hard,
it's
just
a
little
bit
of
typescript
and
you
know
blah
blah
blah
but
like
there's,
there's
quite
the
complexity
hill
to
climb
here,
if
you're
not
already,
if
this
isn't
already
part
of
your
skill
set-
and
I
don't
think
this
is
a
knock
on
sort
of
cdk
in
general,
I
just
think
it's
like
how
hard
this
problem
is.
Is
that
there
is
really
no
one-size-fits-all
solution.
A
All
right,
and
so
that's
justin
says
it
would
be
nice
if
there
is
a
typescript
starter
for
ops
to
use
cdks.
I
I
think
that's
that's
the
case.
I
think,
but
one
of
the
things
that's
interesting
is
that
a
lot
of
ops
folks,
they
understand
bash
right,
there's
a
reason
why
bash
is
never
going
away
and
it's
because
you
start
with
something.
That's
like
super
easy
and
then
you
build
incrementally
that
skill
set
on
top
of
it.
I
think
we
see
the
same
thing
happen
with
powershell
on
the
window
side
right.
A
It's
like
it's
like.
Oh,
I
already
know
all
this
stuff.
Let
me
just
add
incrementally,
on
top
of
it,
I
think,
even
if
we
did
have
a
gentle
introduction
to
typescript
for
operators,
it
still
would
be
this
hump,
where
it's
like.
Okay,
I'm
going
to
have
to
set
aside
a
couple
of
days
to
really
dig
into
this
versus
like
well,
I'm
just
going
to
learn
this
by
osmosis
there's
this
book
that
I
started
reading,
I'm
in
the
middle
of
that,
I
think,
is
really
interesting.
Let
me
find
a
link
for
it.
A
A
But
humans
are
good
at
strategy
and
one
the
chapter
that
I
just
finished
reading
in
it
starts
to
talk
about
like
what
does
it
take
to
learn
and
really
build
mastery
over
something
and
there's
a
lot
of
data,
and
I
don't
know
sort
of
how
generally
the
general
this
is,
but
there's
a
lot
of
data
out
there.
That
says
that
if
you
train
for
the
exam-
and
you
learn
the
exam,
you
do
well
on
the
exam-
you
think
you
learned
it,
but
it's
not
really
durable.
A
A
You
will
not
actually
end
up
in
a
good
situation
if,
if,
if
you
really
take
on
management
to
that
level
of
detail
without
using
tooling,
it
is
an
amazing
way
to
actually
learn
about
kubernetes
and
actually
dig
under
the
covers,
because
you
have
those
battle
scars,
you
have
the
paper
cuts
you
you
understand.
What
happened
is
because
you've
suffered
through
it,
and
so
I
think
that
that's
it's
that
I
think
does
play
to
this.
A
It's
like,
if
you
have
the
battle
scars
of
learning
javascript
and
the
battle
stars
of
actually
scars
of
becoming
a
developer.
Something
like
cdk
makes
a
ton
of
sense.
If
all
of
your
battle
scars
are
around,
you
know
bash,
then
then
cdk
may
actually
end
up
being
really
really
daunting,
because
there
is
that
sort
of.
I
have
to
be
a
programmer
hump
that
not
everybody
has
gotten
over.
A
I
don't
know
I'm
kind
of
hand
waving
here,
but
that's
my
sort
of
theory
on
this
stuff
a
little
bit
okay.
So
I'm
going
to
finish
off
I'm
talking
about
my
shirt
so
before
the
pandemic,
I
used
to
travel
a
lot
and-
and
usually
I
do
like
day
trips
down
to
the
bay
area
where
it's
like
you
leave
really
really
early
in
the
morning.
A
You
catch
like
a
6
a.m:
flight
out
of
seattle,
tacoma
get
down
to
the
bay
area
and
then
I'll
be
home
around,
like
I
don't
know,
10
or
11.
really
long
day
once
in
a
while,
I
would
stay
overnight,
and
so
you
know
oftentimes
I'll
have
another
bag.
Well,
I
went
I
was
doing
like
an
overnight
trip
and
I
got
to
the
airport
only
to
realize
that,
like
my
bag
was
still
at
home,
and
so
I
I
had
to
play
that
game
of
like
okay.
A
What
do
I
need
to
buy
in
the
airport?
So
that,
like
you
know,
I
can
stuff
it
in
my
backpack
and
I'm
not
going
to
actually
be
be
embarrassed
the
next
day
by
not
having
clean
clothes,
and
so
this
is
actually
from
the
from
the
which
mccall
record
label
in
seattle,
man,
I'm
really
blanking
today,
god
and
they
have
a
store
in
seatac.
Someone
help
me
here
so
now,
I'm
gonna!
Look
it
up.
So
hey
google
record
label
in
seattle.
A
So
this
is
some
pop
t-shirt
that
I
picked
up
on
the
airport
because
I
actually
forgot
my
bag.
I
also
got
a
pair
of
socks
and
a
pair
of
undies
out
of
it,
but
this
has
been
the
most
durable.
Actually,
it's
a
really
nice
t-shirt,
and
so
it's
it's
almost
worn
out
now.
Yes,
I've
washed
it
many
times
it's
getting
kind
of
threadbare,
so
that
was
a
while
ago,
so
yeah.
So
it's
a
it's
a
space
needle
and
I
think
it's
a
like
a
sasquatch.
A
My
only
regret
is
that
it's
a
hexagon
and
not
a
heptagon,
but
what
are
you
going
to
do
all
right?
Well
with
that
I
will
say
have
a
great
weekend.
Thank
you
for
joining
me.
Let's
hope
that
we
have
a
good
2021
together,
get
over
the
pandemic
and
let's,
let's
build
a
a
fair,
more
equitable,
calmer
future
together.