►
From YouTube: TGI Kubernetes 161: Let's Build a Buildpack
Description
Notes: https://tgik.io/notes
Come hang out with Evan Anderson as he explores Cloud Native Buildpacks! We'll probably be taking a look at what it takes to add some Python code to an existing buildpack, and then trying to run both local and on-cluster builds using the same (repeatable) tools.
A
Hello,
everyone
welcome
to
tgik
and
it
looks
like
people
are
starting
to
come
in
so
I'll
be
getting
started
shortly.
This
week's
topic
is
cloud
native,
build
packs
for
those
of
you
who
aren't
familiar
with
them.
We
will
be
learning
a
little
bit
about
how
they
work
and
then
I'll
be
actually
trying
to
build
one
live
on
screen.
I
guess
not
really
on
stage,
and
I've
never
done
this
before
so
we'll
see
how
it
goes.
B
A
A
B
E
A
B
A
A
So
I
called
out
two
in
particular
that
were
introduced
in
119,
but
if
you
want
the
full
list
in
this
blog
post,
you
can
see
that
there's
web
hook
configurations
and
crds
and
api
registration.
So
this
is,
if
you're
doing
your
own
custom
api
server
token
review
for
authentication
the
beta
version.
Again.
These.
A
I
had
a
cluster
that
I
got
to
learn
a
lot
more
about
a
td
than
I
wanted
to
when
I
didn't
upgrade.
That
was
that
had
cut
out
a
particular
api
version
and
I
didn't
realize
I
was
using
it
so
certificate
signing
requests,
leases
and
ingress
is
the
other
big
one,
both
extensions
v1,
beta,
1
and
networking
case
side.
I
have
v1
beta1,
so.
B
A
So
yeah,
you
should
be
able
to
use
that
link
to
add
notes,
or
you
can
add
them
in
chat
and
I'll
copy
them
over
here.
Two
things
I
am
aware
of:
there's
a
contour
security
release
and
the
bug
here
is
actually
kind
of
interesting.
You
can
create
an
http
proxy
that
points
to
an
external
name
service
which
is
usually
used
to
say,
here's
something
off
cluster,
but
you,
oh,
that
sounds
pretty
exciting.
A
B
A
A
A
A
A
A
D
C
A
A
A
A
A
A
In
the
docs
yeah,
so
there's
a
bunch
of
different
tools
that
all
implement
these
build
pack
commands
so
circle
ci
and
get
lab
use
pack.
There's
a
tool
called
kpac
that
lets
you.
That
gives
you
a
kubernetes
version
of
the
pack
command
that
will
automatically
rebuild
when
your
source
or
your
base
images
change.
We're
going
to
probably
be
mostly
using
pac
today
and
then
techton.
Also,
if
you're
using
tekton
for
build,
has
a
way
to
use,
build
packs
automatically.
A
A
B
A
And
one
of
the
neat
things
that
they
support
is
this
auto
detection,
so
you
can
actually
put
together
a
build
pack
that
will
figure
out.
Oh,
this
is
a
javascript
project,
or
this
is
a
java
project
and
you
don't
have
to
you.
Don't
you
don't
have
to
know
in
your
build
system
like
we're
on
a
different
command
for
this
or
that
you
just
say,
run
this
build
pack
and
it
will
figure
out
which
sub
builders
it
needs
to
execute,
and
so
one.
E
A
Things
that
throws
me
for
a
loop
here
and
I'm
probably
going
to
get
it
wrong
at
least
once
I've
talked
with
some
people,
but
never
actually
built.
One
of
these
is
the
difference
between
a
builder,
a
build
pack,
and
I'm
not
sure
if
there's
another
component
in
here
or
not,
but
there's
a
couple,
things
named
build
something,
and
I
tend
to
mix
them
up
so
builder
is
actually
the
image.
A
I'm
not
quite
sure
I
see
carlos
asked
a
question
about.
Is
it
a
way
you
use
a
different
stack
like
alpine,
I'm
not
sure
what
that's
about
and
then
is
there
a
tool
which
supports
deployment
of
operators
again,
you
might
need
to
ask
that
question
a
slightly
different
way,
we're
focusing
on
creating
containers
today
from
source
code,
so
we
might
not
get
to
anything
using
a
kubernetes
operator
today.
A
E
E
D
B
D
D
B
B
A
E
B
A
A
C
B
B
A
A
A
Going
to
go
and
fetch
all
the
different
components
needed
to
do
a
build
with
java
in
docker
images
and
run,
and
I
don't
need
to
have
docker
installed
on
my
local
or
have
java
installed
on
my
machine
to
do
a
maven
build
or
have
maven
installed
and
this
process,
because
it's
building
in
docker
containers
is
actually
going
to
work.
The
same
if
you're,
on
a
mac
or
on
windows.
A
A
A
B
A
Thing
here
is:
if
you
look
at
this
project,
there's
actually
nothing
that
specifically
clues
you
in
that
it's
using
build
packs
at
all.
It
just
looks
like
a
standard
maven
project
and
let's
see
what
the
application
is
going
to
be
looks
like
it
just
runs.
The
application
doesn't
even
print
anything
out.
C
A
C
B
A
A
A
C
A
C
B
A
C
B
B
A
D
E
A
A
A
E
E
E
E
E
E
A
D
E
A
E
A
Before
we
start
the
application,
oh
and
one
thing-
I
don't
know,
if
you
noticed,
I
don't
have
the
java
extensions
installed
even
here,
so
I'm
really
doing
this
on
a
machine
without
java,
but
we
can
just
do
a
pack
build
and
the
second
time
we
shouldn't
hit
all
of
the
video
problems,
because
all
of
the
containers
are
cached
and
look
at
that.
This
is
the
time
for
building
the
second
copy
of
my
app
and
then
I'm
actually
going
to
go
over
here
to
do
a
docker.
B
C
E
A
A
A
A
A
I
know
that
it
feels
like
it
should
be
really
easy
to
get
a
theme
for
documentation
for
open
source.
It
turns
out
it's
really
hard,
so
I'm
not
going
to
give
them
a
hard
time
about
this
huge
menu
at
the
top,
because
on
the
candidate
project,
we've
been
fighting
the
same
thing
and
it
was
hard
so
so
they're
going
to
walk
us
through
a
ruby
example,
but
I
want
to
do
python,
so
I
that's
wsl.
We
may
not
need
window
subsystem
at
all.
D
D
E
A
A
If
this
all
goes
well
in
the
next
40-ish
minutes,
or
so,
I
may
actually
end
up
building
a
function,
build
pack
for
k-native
that
will
transform
a
function
like
this.
That
takes
an
http
request
into
a
into
a
full-blown
canadian
application,
but
I
might
not
get
to
that.
So
I'm
not
gonna
fight,
I'm
not
going
to
rush
things
and
skip
over
the
learning
so
that
the
build
pack
scaffolding
create
a
directory
where
your
build
pack
will
live.
D
E
B
A
A
D
A
A
E
D
A
A
A
B
E
A
C
A
E
D
D
D
A
E
A
D
A
A
B
D
A
A
A
E
C
B
C
C
D
A
A
A
D
A
Yeah,
I
probably
would
want
to
install
python
3
pip,
so
now
I'm
discovering
why
it
is
that
a
lot
of
these
are
shell,
build
packs
or
are
using
shell
here.
Is
that
otherwise
you
have
to
build
your
own
stack,
but
I'm
not
deterred.
I'm
going
to
try
to
build
my
own
stack.
I'm
also
going
to
try
installing
python
3,
because.
B
A
E
C
B
A
D
A
A
A
Okay,
so
here's
our
image,
the
builder
image,
is
an
amd64.
It
looks
like
the
created.
Timestamp
is
all
emptied
out.
It's
linux
here
are
the
different
layers.
It
runs
bash.
Here's
the
environment
and
here
are
the
labels
that
it
has
that
we
were
seeing
complaints
about
earlier
when
we
tried
to
do
that
build
it
was
saying
validating
that
this
builder
exists.
E
E
E
D
D
C
D
B
E
D
E
A
D
E
C
A
Oh,
I
was
just
looking
at
this
and
it
looks
like
maybe
in
adding
pip
is
adding
a
dependency
on
the
c
plus
compiler
and
a
bunch
of
other
stuff,
so
yeah.
One
of
the
reasons
that
build
packs
are
nice.
Is
you
you
do
basically
the
two-stage
docker
build
where
you
have
one
build
that
has
all
of
your
containers
or
sorry
that
has
like
your
source
code
and
your
compiler
and
so
forth,
and
then
you
specifically
take
the
artifacts.
A
You
want
in
your
run
environment
and
you
move
them
over
from
the
build
environment
to
the
run
environment,
and
then
you
throw
away
the
build
environment.
So
you
end
up
with
a
final
image
that
doesn't
have,
for
example,
a
c
compiler
in
it
or
doesn't
have
you
know
other
libraries
and
things
like
that?
A
So
that's
that's
nice
for
security,
because
stuff
that
you
haven't
built
into
your
image
is
stuff
that
you
don't
have
to
worry
about
vulnerabilities
for
it's
also
nice
for
a
for
a
system
like
k,
native
where
you
may
be
starting
containers.
Frequently
having
smaller
containers
means
that
your
containers
will
start
up
faster
and
aren't
going
to
have.
A
A
So
if
you
have
a
big
container,
even
if
you
don't
use
90
of
it,
it
all
has
to
come
down
onto
disk.
It
all
has
to
get
unzipped.
It
all
has
to
get
put
back
down
onto
disk
and
so
being
able
instead
to
say:
oh,
it's
80
megabytes
or
something
like
that
is
pretty
useful
and
let's
just
get
a
sense
of
how
big.
A
A
A
A
If
you
did
this
in
a
second
command
after
the
first
one,
you'd
actually
create
a
layer
that
had
all
you
of
your
apt-get
update
contents
and
then
another
layer
that
takes
them
away,
but
you
have
to
download
both
layers,
so
you
don't
actually
save
any
space.
So
that's
why
you
see
these
big
docker
commands
with
a
bunch
of
commands,
strung
together
with
ampersand,
is
that
each
run
line
creates
a
new
container,
which
is
good
for
caching
sometimes,
but
is
awkward
to
read.
A
A
A
D
D
D
A
E
A
A
We
got
pearl
somehow
so
yeah.
If
you
didn't
want
a.
If
you
didn't
want
pearl
and
a
c
plus
compiler
in
your
images,
then
it
seems
like
this
would
be
the
way
to
go,
to
have
a
separate,
build
image
so
that
you
can
leave
stuff
like
c
plus,
plus
and
pearl
out,
even
if
you
need
them
as
part
of
your
build.
D
A
D
A
D
E
D
D
E
A
A
A
It's
actually
wiped
out
the
command,
interestingly,
but
here's
a
layer
with
14
megs
of
changes
and,
let's
see
if
we
remove
so
this
has
added
the
cnb
lifecycle
and
launcher
which
provides
the
analyze,
build,
create,
detect
and
so
forth
commands.
And
then
this
actually
has
our
bit
our
bin
build
our
build
and
detect
commands
and
our
buildpack.toml
and
then
there's
the
order
that
the
thing
should
be
running,
what
stack
it's
using
and
then,
if
we
look
at
this.
E
A
A
A
D
A
So
crane
will
unpack
all
let's
feed
it
to
jq,
and
so
this
will
show
you
all
the
different
layers
and
all
the
different
metadata
with
crane
config.
You
can
also
oops
yeah,
so
crane
append
will
let
you
take
a
tarball
and
add
it
on
to
an
image.
So
you
can
actually
build
a
new
image
with
just
a
new
tarball
to
add
a
new
layer.
A
Blob
will
let
you
read
out
one
of
these
layers
into
a
targe
zip
without
needing
to
fetch
everything
down
and,
let's
see
what
are
some
of
the
other
export
will
take
all
the
different
layers
and
collapse
them
into
a
single
tarball,
which
makes
it
handy
for
if
you
want
to
just
see,
what's
in
there
list
the
tags
in
a
repos.
What
ls
is.
A
A
A
A
A
So
pack
builder
creates
a
builder
image,
so
it
takes
your
base
image
that
you're
going
to
run
all
of
your
software
on,
and
it
adds
your
build
packs
on
top
of
it,
so
that
all
your
build
packs
get
packaged
up
and
can
run,
and
that's
an
image
that
you
pass
around,
that
your
developers
will
fetch
and
use
to
actually
build
their
software
pack
build,
which
is
two
letters.
Less
is
when
you
take
your
source
code
and
you
feed
it
through
a
builder
created
through
pack
builder.
A
A
It
does
sort
of
feel
like
everything
has
to
start
with
build,
which
is
not
great.
Okay,
oh,
it's
called
python3
and
it
looks
like
there
isn't
a
python.
So
if
we
change
this
to
which
python
three
naming
is
hard,
I
completely
agree
and
the
way
you
name
things
affects
how
you
think
about
them.
So
it's
really
important
too
so
yeah.
E
A
A
D
A
E
E
B
A
B
D
C
C
E
A
D
E
B
A
A
E
A
A
D
A
E
D
A
B
D
D
A
That
java
image
that
we
built
at
the
beginning
was
well
didn't
get
quite
as
far
as
I
expected
to
here,
but
I
did
manage
to
build
a
base
stack
that
included
python
and
start
using
python
in
my
detect
script,
so
that
I
could
determine
if
there
was
actually
a
function
there,
like
one
thing
I
might
decide
to
do,
would
be
to
figure
out.
Is
there
a
main?
A
If
there's
a
main,
I
probably
shouldn't
inject
my
own
main
for
transforming
a
function
into
an
http
server?
If
there
isn't
a
main,
then
maybe
I
do
that
and
I
figure
out
which
functions.
Look
like
they're
likely
to
be
things
that
you
want
to
expose
through
the
web
service-
and
I
you
know,
maybe
there's
annotations
on
them
or
maybe
I
add
the
annotations
and
I
wrap
it
up
into
a
flask
application.
A
A
A
Yeah
so
for
java,
jib
is
a
competitor
here.
Jib
is
a
sort
of
a
local
build
tool.
So
I
think
that
there,
I
think,
there's
probably
some
synergy
between
jib
and
pack
in
that
you
could
actually
have
a
cloud
native
builder
that
used
jib
to
do
that
build
and
then
you
don't
necessarily
have
to
have
docker
installed
locally,
although
maybe
you
install
docker
locally
to
run
pac,
but
if
you're
using
something
like
tekton
to
kick
off
your
ci
cd,
then
that's
that
should
give
you
what
you
need.
A
A
So
yeah,
hopefully
this
was
interesting
and
exciting
and
yeah
go
play
with
cloud
native,
build
packs
but
yeah.
If
someone
wants
to
suggest
jib
as
a
topic
as
well,
I
think
there
might
have
been
an
earlier
look
at
either
jib
or
co,
which
are
similar
tools.
Co
is
for
go,
and
jib
is
for
java
that
lets.
You
build
a
docker
image
sort
of
natively
using
the
container
registry
apis
rather
than
using,
rather
than
using
the
docker
client
and
building
up
layers.
That
way
so
have
a
good.