►
From YouTube: Tutorial: Say Goodbye to YAML Engineering with the CDK for K8s - Nathan Taber & Elad Ben-Israel
Description
Don’t miss out! Join us at our upcoming event: KubeCon + CloudNativeCon Europe 2021 Virtual from May 4–7, 2021. Learn more at https://kubecon.io. The conference features presentations from developers and end users of Kubernetes, Prometheus, Envoy, and all of the other CNCF-hosted projects.
Tutorial: Say Goodbye to YAML Engineering with the CDK for Kubernetes - Nathan Taber & Elad Ben-Israel, Amazon
Applications running on Kubernetes are composed of dozens of resources maintained through an intricate collection of carefully maintained YAML files. As applications evolve and teams grow, these files become hard to manage and reuse — copying & pasting from previous projects is not the solution! The CDK for Kubernetes (cdk8s) is a new open-source software development framework for defining Kubernetes applications and resources using familiar programming languages. In this tutorial, the creators of cdk8s show you how to define your first cdk8s application, design a reusable construct and package it as a library, and generally say goodbye (and thank you very much) to writing in YAML. Bring your laptops set up with your favorite development environment in one of the supported languages (TypeScript, JavaScript, Python, Java, or .NET).
https://sched.co/ekFN
A
So
let's
go
ahead
and
get
started
here,
so
we
have
a
few
things
we're
going
to
go
over
today.
This
is
a
hands-on
interactive
demonstration
session.
So
I'm
going
to
spend
a
few
minutes
right
now.
Talking
about
you
know,
what's
the
deal
with
yaml?
How
can
we
do
more
with
the
yaml
that
we
have?
How
can
we
use
yaml
as
part
of
the
system
talk
about
cdks
and
and
how
cdks
help
solve
some
of
the
common
problems
that
we
see?
A
People
in
the
kubernetes
community
having
around
yaml,
especially
as
they
define
and
build,
really
complex
applications
across
organizations,
and
then
we
have
a
really
awesome
deep
dive,
hands-on
demo
that
ellie
and
a
lot
are
going
to
give
they're
going
to
go
all
the
way
through
how
to
deploy
an
app
end-to-end
with
a
cdk
for
kubernetes
on
a
kubernetes
cluster
and
then
finally,
we're
going
to
have
a
really
quick
wrap
up.
So
I'm
really
excited
that
you've
joined
us
for
this
session
at
kubecon.
A
Here
we
are
live
from
home
and
let's
go
ahead
and
get
started.
So
let's
talk
about
yemo
yamo
is
freaking.
Awesome
I
mean
yemol
is:
is
the
the
bleeding
the
beating
heart
right
of
kubernetes
cluster?
It's
how
we
configure
all
the
stuff
that
we
run
using
kubernetes
and
yaml
is
great,
because
it's
really
easy
for
humans
to
read
it's
something
that
anybody
can
open
up
a
configuration
spec.
They
can
look
at
it.
They
can
understand
exactly
what's
going
on
exactly
what
we
intend
for
the
system
to
do
it's
universal.
A
It's
also
declarative,
which
is
great
in
a
system
like
kubernetes,
because
you
declare
exactly
what
you
want
and
then
you
expect
the
api
server
and
all
the
other
resources
to
take
care
of
instantiating
that
declared
state
and
maintaining
that
declared
state
so
yaml,
is,
is
a
great
language
for
how
you
want
to
declare
things
on
your
cluster,
and
it's
also
really
good,
because
it's
static
and
things
that
are
static
are
easy
to
work
with.
They
can
be
versioned.
A
You
know
they
can
be
shared
and
distributed
and
understood
at
a
single
point
in
time.
So
that's
really
good.
So
yaml
is
a
really
excellent
building
block
for
our
applications
and
it's
not
too
hard
to
use.
When
you
have
a
few
things,
if
you
have
you
know
a
handful
of
deployments
or
a
handful
of
services
in
your
cluster
yaml
is
really
great.
A
You
can
probably
just
write
out
a
yaml
spec
really
easily
and
start
running
some
basic
applications
on
kubernetes,
but
as
you
grow,
and
especially
as
you
start
to
adopt
systems
defined
in
yaml
across
your
organization,
you
end
up
with
this
yaml
engineering.
There's
a
lot
of
boilerplate
that
you
start
having
to
add,
and
that
opens
up
room
for
errors,
sharing
becomes
kind
of
manual
and
hacky
right.
A
Like
projects
often
start
with
these
off
the
shelf
examples,
then
they
start
quarking,
copying
and
pasting
configurations
from
vendors
from
other
companies
from
community
maintained
repositories
and
maintaining
these
files
over
time
takes
a
lot
of
work
and
there's
a
lot
of
different
tools
that
we've
seen
created
by
the
community.
Some
like
helm
are
really
good
at
packaging
yaml
and
making
it
easy
to
bundle
yaml
together,
but
they
don't
actually
necessarily
solve
some
of
the
underlying
problems
about
customizations
and
all
the
different
tooling
that
you
have
to
use.
A
How
do
you
update
across
lots
of
different
things,
especially
when,
if
you're
a
human
right
like
if
you're
a
developer
and
you've
never
actually
touched
kubernetes
yaml?
It's
this
whole
other
world
to
actually
begin
to
start
to
run
your
application
on
kubernetes,
and
we
find
that
that
can
be
a
bit
of
a
learning
curve
for
people
and
most
developers
are
are
used
to
working
with
general
purpose.
Languages
right
so
general
purpose
languages
are,
are
what
we
actually
build.
Our
applications
in
they
tend
to
be
specialized,
they
can
be
functional
or
imperative.
A
A
So
what
the
cloud
development
kit
for
kubernetes
does
is
it's
an
open
source
framework
that
lets
you
define
kubernetes
infrastructure
using
these
general
purpose,
popular
programming
languages?
So
the
cd
case
is
really
awesome.
It
lets
you
go
from
code
to
config,
defining
kubernetes
applications
and
architectures
using
you,
know
popular
and
familiar
programming
languages,
and
it
gets
rid
of
a
lot
of
the
pain
of
making
sure
that
you
get
all
the
boilerplate
right.
So
you
can
generate
that
well,
formatted
yaml
for
your
applications,
every
single
time,
because
it
actually
you're
defining
your
applications
in
code.
A
You
can
use
code,
libraries
and
you
can
actually
define
the
format
for
how
you
want
a
particular
application
within
a
cluster
to
work
as
a
code
library,
and
then
you
can
share
that
and
you
can
update
it
easily
without
any
heavy
lifting.
So
you
can
go
and
you
can
update
you
know
how
do
I
define
a
web
service
at
my
organization
and
let's
say
tomorrow
you
come
out
with
okay.
A
I
think
the
most
important
part
of
this
project,
and
what's
really
exciting
for
us
at
aws,
is
that
cdks
lets
you
run
everywhere
so
is
is
not
a
system
that's
designed
just
for
aws.
It
runs
locally
on
your
machine
and
it
generates
kubernetes
standard
yaml
that
you
can
deploy
to
any
kubernetes
cluster
running
anywhere,
and
this
lets
you
standardize
across
on-premises
and
any
cloud.
A
So
today
we
support
four
languages
with
cdks,
typescript,
javascript,
python
and
java,
and
we're
looking
at
supporting,
go
and
dotnet
and
many
more
in
the
future
and,
like
I
was
saying
cd
kate's,
is,
is
lets.
You
share
these
best
practices
as
libraries.
It
makes
them
easy
to
maintain
and
and
it's
easier
to
share
than
templates.
So
you
can
use
cdks
to
standardize
how
you
define
kubernetes
across
your
organization
and
across
any
environment,
and
then
what's
really
cool.
Is
that
at
the
end
of
the
day,
what
you're
using
is
just
standard
kubernetes
yaml.
A
And
then
you
can
deploy
that
out
through
a
git
ops
through
a
cd
pipeline
onto
your
cluster.
So
you
can
go
from
having
two
very
different
flows
from
writing
your
code
and
getting
it
into
production
and
actually
unify
that
and
use
the
same
set
of
tools
all
the
way
through
the
process.
From
writing
your
application,
defining
how
it
should
run
and
then
using
continuous
deployment
and
continuous
integration
to
get
that
out
onto
your
cluster.
A
So
let's
take
a
quick
look
at
how
this
actually
works.
So
in
the
cdks
you
have
a
cdks
application.
This
represents
the
overall
application
that
that
you're
going
to
be
running
on
your
cluster
and
then
you
have
a
series
of
charts
and
charts
are
different,
logical
modules.
Within
your
application
for
different
functions
and
within
a
chart
you
can
have
one
or
more
constructs
and
a
construct
defines
one
or
more
resources,
kubernetes
resources
that
you
want
to
instantiate
and
define
together.
A
A
The
cdk
cli,
which
is
our
our
cli
tool,
acts
as
the
compiler
and
the
cli
executes
that
source
and
synthesizes,
yaml
or
helm
chart.
That
is
your
assembly
language
right
and
then
we
deploy
that
onto
the
kubernetes
cluster,
which
is
your
processor
and
actually
instantiates
those
kubernetes
resources
to
run
your
application,
and
so
there
are
three
main
components
to
the
cdks
there's
the
core
framework,
which
is
all
the
different
constructs
in
the
construct
library
that
that
makes
that
up.
We
also
have
cdks,
plus
and
cd.
A
B
B
C
B
Yeah
we
actually
planned,
you
know
we
sat
down
and
planned
and
there's
so
much
stuff
to
talk
about,
and
so
many
rat
holes
to
go,
and
so
I
I
asked
ellie
to
keep
me
honest
and
make
sure
that
I
pull
me
out
of
those
rat
holes
as
much
as
possible,
so
we
can
actually
get
something
achieved.
What
what
what
we
said,
we're
going
to
do
is
first
kind
of
walk
through
the
basics
to
make
sure
that
everybody's
on
the
same
page,
I
know
that
some
of
you
are
probably
used
cdk
for
kubernetes.
B
Some
of
you
have
never
heard
of
it
and
so
yeah.
You
know
following
nate's
introduction.
I
hope
you
have
a
sense
of
what
it
is,
but
I
actually
want
to
show
you
you
know
hands-on
how
how
it
feels
to
use
it
and
then
we're
gonna
just
try
to
build
a
project
together
and
you
know
have
some
cathars
cathartic
experience.
I
think,
like
that.
That's
always
good.
B
C
A
B
Awesome
project
really
really
stable.
I
think
one
of
the
things
that
we
get
asked
a
lot
is
whether
cdks
is
just
for
aws,
and
the
answer
is
no
cdk
for
kubernetes
is
for
kubernetes,
and
so
you
can
run
on
any
kubernetes
cluster,
whether
it's
ram
on
the
cloud
as
nate
said
it.
Basically,
just
synthesizes
yaml
manifests
it's.
If
you
think
about
it's
kind
of
like
a
compiler,
you
write
code
and
you
execute
and
you
get
a
manifest
output.
B
And
we'll
see
we'll
see
all
of
that
in
a
second.
The
second
thing
that
I
prepared
in
advance
is
just
an
empty
kind
of
like
an
empty
typescript
project.
We're
gonna
use
typescript.
As
nate
said,
the
cdk
supports
multiple
programming
languages,
typescript
javascript.net
java
go
is
coming
up,
hopefully
in.
A
B
Okay,
but
this
is
basically
just
a
regular
typescript
app
and
what
you
see
here
is
a
boilerplate,
not
boilerplate,
but
basically
kind
of
like
a
starter
application
that
was
created
by
cdks
init
cdks
is
shipped
with
a
cli
called
unsurprisingly
cdks,
and
it
has
a
bunch
of
commands
and
one
of
them
is
in
it.
It
allows
you
to
just
initialize
new
projects
in
in
one
of
the
supported
languages.
There's
nothing
fancy
about
these
projects
or
just
regular.
You
know
regular
projects.
B
Quickly,
but
you
can
start
with
with
from
an
empty
textured
project:
it's
not
really
okay
and
then
the
structure
that
you
get
here
is
kind
of
like
what
we
call
the
construct
tree
and
we'll
talk
more
about
constructs,
I
guess
later,
but
the
mental
model
is
a
tree.
Okay,
so
think
think,
there's
a
root
and
the
root
of
the
tree
is
the
app
and
then
within
the
app
you've
got
charts
any
number
of
charts,
and
the
reason
is
that
every
chart
synthesizes
into
its
own
manifest.
B
B
C
Resource
so
I
know
that,
like
I
want
to
talk
about
the
the
the
kind
of
a
very
important
aspect
of
cdks-
and
you
know
software
engineering
in
general,
which
is
this
notion
of
of
layering,
and
I
want
us
to
show
to
see
all
the
different
types
of
layering
that
syndicates
cdks
offers
and,
let's
start
by
by
using
like
the
most
basic
layer
to
define
objects
and,
let's
just
start
with
like
a
simple
config
map.
Right.
That's
something!
That's
super
super
simple
to
configure.
C
B
Manifests
are
structured
as
a
collection
of
api
objects,
and
so
to
that
end,
cdks
is
also
bundled
with
a
class
called
api
object.
It's
also
a
construct,
so
it
needs
to
bind
to
the
tree.
The
first
parameter
is
the
scope
and,
as
a
rule
of
thumb,
I'm
always
going
to
pass
in
this,
because
I
want
to
add
this
construct
to
the
scope
in
which
I'm
actually
defining
it.
So
I
know
exactly
what's
going
on
within
this
scope.
You
want
to
keep
keep
the
locality
of
your
resources.
I
want
yeah.
B
I
want
this
to
be
local
to
my
chart
in
that
sense
and
we'll
see
what
that
means.
Maybe
later,
and
then
I
get
a
name
for
my
api
object.
I
can
call
it
config
map,
let's
say,
and
if
I
look
if
I
ask
the
ide
to
help
me
that
I
see
that
I
need
api
version
and
I
need
kind
because
both
of
those
are
required
for
all
api
objects.
C
C
B
C
B
C
B
Right
and
so
the
way
it
works
is
basically,
I
just
run
my
application
right.
This
application,
you
see
the
last
line
in
my
application,
synth
and
you'll
see
this
also
come.
You
know
repeating
in
other
cdks
like
the
kubernetes
cd,
also
the
terraform
cdk
or
the
aws
cdk,
and
so,
if
I
run
this
application.
C
A
B
Because
in
kubernetes,
names
are
required
for
for
resources,
and
and
but
this
is
actually
a
unique
thing
about
cdk
for
kubernetes
and
a
very
key
ingredient
of
cdk.
I
didn't
have
to
specify
a
name
because
cdk
can
allocate
a
name
for
this
object
based
on
where
it
is
in
the
construct
tree.
And
so,
if
you
look
at
this
name
you,
actually
you
can
actually
identify
the
path
right,
like
you
say,
hello,
that's
the
name
of
my
application,
hello,
kubecon,
sorry,
hello,
keeper!
B
B
C
And
an
important
thing
is
that
these
names,
like
from
my
experience,
usually
when
you
want
to
wire
components
together,
you
need
access
to
the
name.
So
what
I
found
myself
a
lot
of
the
times
doing
is,
you
know,
obviously
inputting
a
specific
name
and
then
kind
of
repeating
itself,
repeating
myself
around
the
the
the
ammo.
So
I
do
need
some
kind
of
programmatic
access
to
this
name
if
it
is
generated
for
me,
so
that
I
can
pass
it
on
to
other
objects.
B
Exactly
and
and
so
like
any
object
in
object,
oriented
programming
constructs
also
have
an
api
that
you
can
access
after
the
object
is
created
and
api
objects
have
a
pretty
minimal
api
right,
like
you
could
access
some
of
those
properties.
We
actually
plan
to
expand
that
a
little
bit
in
our
roadmap,
but
the
the
interesting
one
is
name,
and
you
can
see
here.
This
is
the
name
specif
either
specified
explicitly
via
metadata
name
you
can.
B
B
C
B
Exactly
and
and
it's
a
very
important
principle
in
healthy
software
engineering-
don't
don't
repeat
yourself
and
one
at
one
end
and
the
other
part
is
like
there's
strong
binding
now
between
those
two
things
that
doesn't
exist
here
right
like
here,
it's
actually
very
loose.
You
see
that
you
know
you
see
this
name
actually
repeating
you
see
this
name
actually
over
here
and
again.
The
beauty
of
this
is
that
if
this
resource
goes
away,
then
my
compiler
will
yell
at
me.
It
will
say:
hey
jobs
doesn't
exist.
What
are
you
referencing
here?
B
So
we
we
we
we
convert
these
this
loose
coupling,
that's
very
prevalent
in
configuration
files
and
benefit
and
kubernetes
manifest.
We'll
see
that
quite
a
lot
in
cdks
with
strong,
binding,
strong
coupling
between
things
that
represent
logical
connections
and
the
compilers
can
help
us
enforce
those
connections
which
is
very
powerful.
C
B
C
B
Yeah,
so
the
beauty
of
the
kubernetes
ecosystem
is
that
apis
are
well
typed.
They're
all
schematized
kubernetes
itself
publishes
an
api,
an
open
api
specification
for
all
of
the
kubernetes
api
objects.
Custom
research
definitions
are
schematized
through
json
schemas,
and
so
what
we
could
do
is
we
could
basically
read
those
schemas
and
automatically
generate
classes
that
represents
each
api
object
and
based
on
these
schemas,
they
offer
rich
and
object-oriented.
C
B
Like
we've
seen,
people
do
really
beautiful
things
with
this
and
you
get
a
very
nice
development
developer
experience
for
you
know
working
with
all
of
the
kubernetes
ecosystem,
not
just
the
kubernetes
apis.
In
this
case,
let's
start
with
the
kubernetes
api,
the
core
api.
Just
to
give
you
a
sense
of
what
that
looks
like,
and
so
I'm
just
going
to
do,
k8s
and
that's
going
to
be
importing
the
k
kubernetes
apis
with
the
default
version.
B
You
can
specify
any
version
and
it'll
it'll
just
use
that
version,
and
so
what
import
is
doing
it
creates
a
directory
called
imports.
It's
becoming
part
of
your
project.
Now
it's
just
that
it
emitted
this
typescript
file
in
it
and
if
you're
using
java
it'll
be
java
classes
or
python
or
whatever
language
you're
using
that's.
B
And
wait:
wait
until
you
see
how
we
use
it
and
so
we're
gonna
do
import
this
into
my
my
application.
I'm
gonna
delete
this,
and
now
I
get
classes
for
all
kubernetes
kind.
So
basically
there's
a
one-to-one
mapping
between
kubernetes
kinds
and
constructs
now
and
let's:
let's
should
we
do
config
map
again
or
something
else?
No.
B
So
again
see
you
see
the
construct
signature,
which
is
you
know
binding
into
the
tree.
Let's
call
it
depth
one
and
let's
see
what
it
means
to
define
a
deployment.
So
again
I
see
missing
selector
and
template,
which
is
the
required
two
required
fields,
but
now,
if
I
actually
ask
my
id
to
help,
you
see
that
it's
not
just
saying
hey,
I
want
you,
know
a
spec.
It
says
exactly
what
is
this
of
that
spec,
and
so
I
can
start.
You
know
using
the
id
to
help
me
with
this
thing.
C
C
C
B
A
B
B
We
completely
don't
know
about
that
right,
like
as
a
because
all
of
this
is
generated
from
the
schema,
and
so
we
can
just
represent
the
schema
through
strong
typing,
which
again
is
extremely
valuable.
Right,
like
there
are
many
ide
extensions
and
tools
and
schema
validations
and
linters
that
people
use
to
make
sure
that
their
benefits
are
correct,
but
we
actually
have
all
this
all
these
capabilities
in
you
know
strongly
typed
languages,
and
so
it's
very
easy
for
us
to
just
lift
this
experience
into
those
into
the
into
these
ids.
Okay,
so.
C
C
So
the
the
last
layering
in
in
this
whole
experience
is
something
we
call
cdks,
plus
and
cdksplus
is
basically
a
library
that
we
vent
as
part
of
the
cdk's
tool
chain
and
it
provides
these
higher
level
apis
for
the
same
objects
for
the
same
kubernetes
objects.
So
if
you
take
a
look
at
this
at
this
api,
we
can
see
that
yeah,
there's,
there's
there's
a
bunch
of
of
resources,
they're
the
same
as
the
prior
level
ones,
but
they
offer
slightly
different
api.
B
So
I've
got
deployment
here
and
now
I
actually,
I
can
use
you
s
so
again,
I'll
just
recap
for
a
second
and
then
we
can
I'll
show
you
exactly
how
to
implement
this,
using
the
what
we
call
l2's
level,
two
apis
and
and
those
level
two
apis.
As
you
saw
earlier,
the
kubernetes,
the
cdks
plus
semantics
is
the
same
semantics
as
the
core
kubernetes
resources.
B
We're
not
inventing
a
new
world
in
a
sense
we're
just
offering
a
higher
level
set
of
apis,
not
a
higher
level
set
of
abstractions,
if
that
makes
sense
right,
like
the
I'm
distinguishing
between
elevating
the
api,
abstraction
versus
elevating
the
mental
model
right
and
we'll
actually
see
what
that
means
in
the
in
in
the
future.
But
for
for
this,
in
this
case
I'm
just
I
still
have
deployment.
I
still
need
to
understand
the
concept
of
deployment
and
I
can
actually
specify
my
deployment
specifications
here.
B
C
B
And
then
the
other
thing
that
I
have
here
is
actual
mutation
methods,
because
in
the
cdk,
the
way
we
we
kind
of
think
about
it
is
that
you
can
mutate
the
tree
as
much
as
you
want
until
you
synthesize
and
when
you
synthesize
everything
becomes
immutable
and
then
goes
into
the
immutable
world
of
desired
state-based
deployment.
But
as
long
as
you're
inside
the
cdk
application
and
in
the
execution
of
the
application,
you
can
reach
out
to
objects
and
change
them,
and,
and
so
it
gives
you
a
very,
very
powerful
programming
model.
B
B
And
so,
in
that
case
I
can
just
call
add
container
and
then
I
can
create
a
container
object.
Sorry
container
object
and
specify
image
which
is
required,
yeah
just
and
I'm
just
going
to
use
the
same
command,
and
I
don't
even
have
to
specify
the
name,
although
it's
required
over
there,
because
yeah
there's
some
default,
that's
pretty
sane
right
like
call
it
main,
because
that's
the
main
main
container.
B
C
Well,
it
didn't
it
didn't
require
previously,
when
we
used
the
the
the
lower
level
apis
right,
we
had
to
specify
a
selector
and
we
and
we
specify
a
selector.
Then
we
have
to
specify
labels,
but
here
it
doesn't
say
that
we
need
to
so.
Let's
assume
we
don't.
Let's
assume
that
something
happens,
and
so
we're.
B
Okay,
so
this
is
my
plus
and
you
see
that
it
actually
allocated
a
label
for
me,
which
is
pretty
nifty.
I
didn't
have
to
do
it
right.
Just
it
has
the
ability
to
allocate
stable,
unique
names
which
is
coming
from
the
constructors,
the
capability,
the
constructor
offers,
and-
and
so
I
could
basically
just
describe
my
intent
right.
Like
my
intent
is-
I
want
the
deployment
I
want
to
deploy
a
single
container.
That's
it
done
right.
B
B
Cube
cuddle
doesn't
know
which
resources
you
want
to
remove
right,
because
those
manifests
only
contain
the
desired
state
and
the
desire
to
say
contains
only
the
stuff
that
you
want
to
exist
and
so
prune
labels
are
a
way
to
basically
tell
cube
cuddle
hey.
This
is
what
I
want
to
to
deploy
and
everything
else.
That's
labeled
with
some
label.
That's
not
in
that
list
should
be
erased
because
it
was
basically
here
from
a
previous
iteration
in
the
sense
yeah.
B
B
C
B
Yeah
and
then,
okay,
so
the
way
pro
labels
work
is
basically
I'm
just
going
to
enter
this
apply,
I'm
going
to
say
prune
and
then
again,
and
I
have
to
specify
a
label
that
that's
that's,
you
know
splat.
You
know
basically
consistent
across
all
the
resources,
so
I
need
to
actually
label
all
my
resources
with
the
same
label.
So
I
so
this
print
can
work.
B
I
can
I'll
just
call
it
prune
and
we'll
just
make
up
some
name,
my
booboo
prune
label,
and
but
now
I
actually
need
to
label
those
things
yeah,
the
nice
thing
again,
because
this
is
a
programming
language
and
we
can
do
things
like
traversatory
and
mutate
it
during
runtime
during
synth
synthesis,
then
cdks
offers
this
ability
to
specify
labels
at
this.
At
the
at
the
chart
level.
I
can.
B
C
B
B
That
I
gotta
just
synthesize
first
to
see
how
it
looks.
I'm
sorry,
I
still
I
don't
trust
this
thing
as
much
and
it's
yet,
but
you
can
see
here
that
I
have
this
print
label
here
and
I've
got
this
print
label
here
which
which
is
great,
and
so
now
I
do
okay.
So
I'm
just
going
to
do
this
like
do
it
like
this,
and
so
it's
going
to
basically
configure
all
my
resources
to
include
my
label,
and
I
can
even
do
this.
C
A
B
C
C
We
have
we
have
that
we
have
our
workflow,
we
have
kind
of
all
the
the
layering
figured
out
and
now
we're
going
to
start
building
our
our
application
and,
and
this
time
we're
actually
going
to
create
an
abstraction,
not
just
like
a
an
api
abstraction,
but
actually
a
different
mental
model
right
we
want
to
now.
We
want
to
create
something
for
our
users
and
our
users,
our
developers,
who
don't
necessarily
know
what
deployments
are
or
what
services
are.
C
They
just
want
to
write
their
code
and
we
want
to
provide
some
kind
of
platform
for
them
to
do
it.
So
I
think,
like
one
of
the
most
you
know,
simplest,
yet
powerful
kind
of
use
cases
to
to
actually
deploy
live
applications
is
something
like
like
a
gateway
like
an
api
gateway
where
you
can
specify
you
know,
like
http
routes,
http
paths
that
are
backed
by
docker
applications
that
the
user
writes.
So,
let's,
let's,
let's
try
to.
B
C
C
Basically,
yeah
basically
map
or
route
different
paths,
different
http
paths
to
to
to
different
handlers,
so
we're
gonna
do
powder,
slash
counter
right,
yeah,
let's
do
slash
counter
and
this
has
to
somehow
map
or
you
know,
be
implemented
by
some
docker
application.
I
don't
know
what
is
it,
but
it's
it's
docker,
okay
right,
so
I
want
to
point
to
a
directory
with
a
docker
file
that
I
can
build
and
just
have
it
run
my
okay.
So.
B
C
C
B
C
B
C
B
C
A
B
B
Construct
creating
constructs
is
actually
extremely
easy.
You
just
create
something
that
extends
the
construct
base
class
and
then
it
has
to
accept
it
and
that's
it.
This
is
a
construct,
so
you
see
from
from
that
perspective,
we
can
now
import
it
into
my
app
now.
I
need
to
include-
and
do
you
know
that
typescript
has
you
could
do
this?
Are
you
familiar
with
this?
Is
this
a
clear
method-
and
I
just
jump
over
here-
and
it
declares
a
method
that
supposedly
this
is
the
path
right.
C
C
Is
that
nothing?
That's
it
that
should
be.
That
should
be
the
the
implementation
or
you
know
the
the
invocation
as
far
as
the
user
is
concerned,
so
for
the
implementation,
I
know
we'll
probably
need
to
use
an
ingress,
because
ingress
has
this
capability
of
routing
specific
http
paths
to
different
services
right
to
different
kubernetes
services.
C
B
C
Yeah
so
we're
gonna
use
the
the
add
rule,
there's
a
bunch
of
other
stuff
here,
but
but
the
add
rule
api
is
basically
saying
give
me
a
path.
An
http,
uri,
right
and
and
the
and
the
handler
of
that
path
is
something
that's
called
an
ingress
back
end.
Essentially,
a
back
end
is
just
a
kubernetes
service,
but.
B
C
So
this
is
yeah,
let's
get
this
okay,
so
a
few
of
a
few
of
the
a
few
of
like
our
patterns
is
to
do
like
the
the
from
methods
right
from
methods
is
when
you,
when,
when,
when
a
resource
is
configured
with
something,
that's
called
the
union
type
where
you
can
pass
in
a
few
properties,
but
you
can
only
use
one
of
them
right,
they're,
mutually
exclusive.
So
every
time
you
see
this
kind
of
this
pattern,
you'll
see
in
the
cdks
you'll
see
the
from
pattern.
B
B
C
C
B
B
B
B
You
can
also
specify
a
registry
into
which
you
want
to
push
the
image
we
have
like
a
local
registry
on
exactly
my
setup,
of
course,
and
then
you
can.
You
can
create
a
deployment
and
specify
that
image
you
the
images
uri
through
dot
uri,
so
it
basically
gives
you
your
the
the
exact
uri
of
that
image
that
it's
built.
B
Exactly
but
you
could
do
anything
you
want
right,
we
can
plug
in
any
string.
You
want,
you
could
use
ci
systems
to
publish
your
images
and
wire.
This
information
into
your
cdk
application
then
pass
that
information
into
your
container.
But
this
is
it's
pretty
rudimentary.
We
can
obviously
evolve
it
and
make
it
more
sophisticated,
but
it
will
it.
It's
definitely
going
to
serve
the
purposes
of
this
demo.
So.
B
So
I
need
the
image
okay:
let's
do
this
image
equals
new
image,
see
it
brought
it
over
from
cdks
and
then
I'm
going
to
do
this
and
there
would
be
image.
Gear
and
registry
would
be
this
localhost
5000,
and
here
I'm
going
to
just
put
image
url
and
now
how
do
I
get
the
service
from
the
like?
Do
I
need
to
create
a
service
now.
C
Yeah,
so
we
have
to
create
a
service
right,
because
an
ingress
backend
is
a
service.
But
actually,
if
you
look
at
the
deployment
and
the
api
on
the
deployment
construct,
you'll
notice,
something
that
is
very
familiar
to
kubernetes
users
and
that's
the
exposed
method.
And
it's
essentially
mimicking
the
behavior
of
cube
cuddle
exposed
right
where
you
can
pass
in
a
deployment
and
the
expose
will
actually
wire
and
create
a
service
that
selects
that
deployment
and
routes
to
it.
Okay-
and
you
can
actually
get
the
service
by
just
storing
the
return
value
of
this.
B
C
C
C
B
C
C
B
Now
recap:
just
a
quick
recap:
okay,
I
want
to
emphasize
a
few
things.
Let
me
put
this
here
so
I
think,
like
the
the
the
interesting
discussion
here
is
about
the
mental
model.
What
what
you
described
earlier
as
far
as
the
user
users
of
this
router
are
concerned.
They
don't
know
about
ingress,
they
don't
know
about
deployments.
They
don't
know
about
this
image
thing.
All
they
know
is
that
they've
put
their
code
under
counter
app
and
they've
basically
mounted
in
or
installed
it
onto
this
route
and.
C
That's
it
yeah,
that's
it
and
that's
and
that's
like
this
is
the
the
next
level
of
abstraction
right
now
you
can
publish
this
as
a
as
an
npm
library
or
anything
and
users
can
use
it
without
having
to
know
you
know
what
what
ingresses
are
or
services
or
deployments.
So
it's
a
completely
different
kind
of
mental
model
yeah.
It's.
C
C
B
C
B
C
B
Now,
if
I
deploy
this,
I
should
get
readiness
probes
and
you
see
that
the
user
didn't
change.
Anything
so
think
you
know
think
this
library
slide
router
library,
added
readiness,
pro
readiness
probes
released
a
new
version.
The
users
just
picked
that
up
and
now
they
have
readiness
probes
across
my
entire
company
right
like
I,
nobody
had
to
do
anything
pretty
neat.
I
want
to
see
the
readiness
part
if
you
don't
mind
part
of
my
deployment
right.
B
A
C
B
B
So,
for
obviously,
we
can
do
a
counter
without
like
persisting,
so
you
want
to
add
a
redis.
Let's
I
want
to
first,
like
you
know,
deploy
multiple.
Let's
say
we
just
deploy
three
replicas
of
every
time.
Let's
keep
it
simple
right,
so
I'm
just
gonna
go
to
my
router
and
replicas
are
here
right,
part
of
the
okay
yeah,
okay,
and
if
I
deployed
this.
C
B
C
Things
definitely
let's:
let's:
let's
try
and
install
it
from
hell
and
we
actually
have
support
for
helm
in
cdks,
where
you
can
there's
there's
something
called
a
helm
construct,
of
course,
and
you
can
you
can
specify
which
chart
you
want
to
install
and
the
helm
construct
will
actually
call
helm
underneath
right
for
you
the
same
way
that
cdk's
image
calls
docker.
So
all
these
build
tools
are
kind
of
encapsulated
or
abstracted
away.
Using
these
constructs,
it's.
C
B
B
Field
here
is
chart
vietname,
redis
right
yep,
that's
the
one,
and
what
else
do
we
have
here?
I
see
home
executable,
helm
flags
gives
me
some
ability
to
control
the
execution
and
then
the
release
name
is
optional,
which
yeah
it
probably
says
that
it's
going
to
allocate
it
based
on
where
the
construct
is,
which
is
pretty
cool.
C
C
B
The
name,
so
I
guess
releases
are
kind
of
like
the
scope
right
like
the
construct
scope
for
the
helm
chart.
It
gives
the
ability
to
basically
install
two
radius
in
the
same
cluster
with
different
release
names,
so
the
resources
are
not
conflicting,
but
it's
basically
one
level
of
nesting.
There's
no
tree,
it's
just
a
single
kind
of
name
spacing
for
the
chart.
C
B
Okay-
and
you
know
I
can
actually
like-
derive
this
value
from
some
configuration
of
my
chart,
so
I
can
add
like
something
like
this:
is
you
know
a
dev
environment
and
in
the
dev
environment
I'm
to
disable
the
cluster
and
production?
I
can.
I
can
actually
write
the
the
logic
that
decides
what
what
is
the
configuration
of
my
registration.
B
C
B
C
B
B
C
C
And
since
you're
already
doing
that,
then
we
should
also
expose
some
properties
for
this
construct,
because
we
know
that
we're
going
to
need
the
password
for
redis
in
order
to
connect
right.
So
it
would
be
nice
if
we
have
like
a
property
or
a
method
on
this
class
that
exposes
and
the
same
thing
for
for
the
host.
B
B
C
C
C
B
B
B
Red
is,
I
agree
about
reddit
anyway,
so
it
creates
a
client
and
it
reads
the
host
and
the
password
from
environment
variables.
So
we
need
to
actually
somehow
delegate
put
those
okay,
we'll
I'll,
remember
this
and
then
it
creates
an
http
server.
Oh,
and
it
has
this
nice
get,
you
can
just
get
the
calendar
or
you
can
post
and
then
it'll
increment,
nice.
Okay,
that's
that's,
looks
pretty
straightforward
and
it's
still
80
80..
Okay,
so
all
we
all
we
need
is
to
basically
pass
this
value
to
to
the
to
the
container.
C
B
B
C
C
B
See
so
I
guess
what
we
saw
here
is
we
we
we
saw
basically,
I
I
would
say
three
aspects
of
what
why
cdk
for
kubernetes
is
interesting
and
why,
in
general,
cpk
is
interesting,
yeah.
The
first
thing
is
just
using
programming
languages
now,
general
purpose,
programming,
language,
languages,
object,
oriented
tools,
classes,
inheritance
methods,
property
things
like
that
very
powerful
tools
very
familiar
to
most
programmers,
and
so
to
that
end
I
feel
I
feel
at
home.
I
feel
like
I'm.
B
You
know,
I
have
all
those
tools,
I
I
know
what
to
do
with
them.
The
second
thing
is
the
ability
to
create
higher
level
abstractions
and
obviously
that
stems
from
the
first
point.
But
the
interesting
part
is
this
composition
model
these
constructs,
because
the
the
power
of
constructs
is
the
ability
to
create
this
consistent
and
deterministic
naming
across
executions.
So
when
I
change
something,
I
know
that
this
thing
that
was
some
you
know
in
my
previous
execution-
was
x.
Now
it's
going
to
be
y
and
that's
and
I'm
able
to
have
those
things
together.
C
B
Stable
stable
navy-
and
I
think
the
third
thing
was-
was
this
ability
to
basically
leverage
the
ecosystem
of
the
existing
ecosystem
of
kubernetes.
We
talked
about
crds
and
being
able
to
import
them
and
use
them.
As
you
know,
l1
we
saw
the
helm
support
which
is
kind
of
like
magical.
I
guess
and
we've
wrapped
it
into
a
construct.
We
create
an
abstraction
that
hides
even
hides
the
fact
that
I'm
using
helm
and
nobody
actually
needs
to
go,
and
you
know
yeah
yeah,.
C
C
B
Initially,
I
didn't
trust
it,
but
now
it
feels
like
I,
I
don't
really
care,
because
I
feel
like
it's
actually
doing
what
I'm
telling
it
to
do.
So
it's
pretty
pretty
cool,
oh
and
the
other
thing
that
we
saw
is
we
used
this
image
library,
which
is
this
just
random
library
by
some
dude
in
tel
aviv
that
helped
us
with
all
this?
B
With
with
you
know,
building
and
publishing
the
image
as
part
of
the
cdk
experience,
which
is
also
pretty
cool
like
the
ability
to
publish
these
constructs
and
use
them
as
class.
You
know
as
class
libraries,
I
can
actually
publish
a
whole
application.
A
whole
application
is
a
class
library.
It's
pretty
yeah.
C
A
C
C
B
C
C
There's
a
slack
channel
we'll
you
can
maybe
show
that
while
I
talk
there's
a
slack
channel,
you
can
join.
There
are
monthly
community
meetings
that
you
can
attend
and
actually
brainstorm
with
us
on
features
and
unbox
and
whatever
you
want,
and
we're
really
really
excited
to
build
this
together
right.
This
is
we
we
want
as
many
as
many
use
cases
as
possible
and
really
making
these
apis
so
so
fun.
B
Pleasant
yeah,
pleasant,
delightful
yeah,
I
think
so
yeah
the
homepage
for
cd
case
is
this
one.
Obviously
github
is
is
another
home
page
that
we're
happy
for
you
to
start
from
and
you
can
find
resources
at
the
bottom
of
this
there's
a
bunch
of
resources
about
there's
a
mailing
list.
We've
got
a
weekly,
I'm
sorry,
a
monthly
community
meeting
that
you're.
B
A
Awesome.
Thank
you
a
lot.
Thank
you,
ellie.
That
was
an
awesome
demo.
Thank
you
so
much
for
joining
us
for
this
presentation.
We
hope
you're
as
excited
about
cdks
as
we
are.
We
encourage
you
to
visit
us
on
the
web
to
join
us
on
slack
and
chat
us
with
your
questions
or
the
things
that
you're
building
and
also
join
us
on
github.
We
really
are
excited
and
we
welcome
contributions.