►
From YouTube: Kpack Demo: Tanzu Community Edition
Description
Tom Kennedy talks kpack and does a demo with kpack in Tanzu Community Edition.
https://github.com/pivotal/kpack
https://tanzucommunityedition.io
B
All
right
so,
for
those
of
you
who
don't
know,
kpac
is
a
kubernetes
native
way
to
execute
builds
of
your
application
using
cloud
native,
build
packs,
that's
in
its
simplest
form
kind
of
what
it
is.
So
we
just
went
through
the
whole
process
of
getting
kpak
in
tce,
and
I'm
just
going
to
kind
of
demonstrate
the
basically
the
the
tutorial
that
we
have
in
our
readme
just
kind
of
talk
through
how
that
works.
B
B
B
Instead
of
just
using
cube
cuddle,
though
you
can
just
use
cube
pedal,
so
the
values
I'm
going
to
pass
in
are
for
our
kp
default
repository,
and
this
is
the
repository
that
rcli
is
going
to
use
to
relocate
images
to.
So
when
I
create
various
resources
for
kpac,
it's
going
to
relocate
those
images
to
my
repository
and
then
the
username
and
then
the
password
I
just
I
left
out
for
now.
B
C
B
C
B
So
when
you
try
to
use
kp,
it
will
it'll
yell
at
you
saying
that
it
doesn't
have
the
default
repository
set,
and
at
that
point
you
can
set
it
using
the
kpcli
there's
a
command
called
kp
config
default
repository
and
kpconfig
default
repository
service
account,
which
will
allow
you
to
set
that
later,
but
it
does
involve
you
like
doing
a
little
bit
like
creating
the
service
account.
You
could
also
update
your
values
at
that
point
and
then
just
run.
B
You
know
tansy
package
update,
but
you
can
use
kpac
without
without
setting
any
of
these.
If
you
were
to
just
use
cube
cuddle,
it
would
not
relocate
anything
to
your
own
registry.
You
would
just
like
reference
like
build
packs
and
stuff
like
that
where
they
live,
and
then,
when
you
create
a
builder,
because
a
builder
is
an
actual
image
that
gets
relocated,
you
would
just
have
to
make
sure
there's
a
secret
present
on
the
cluster
builder
resource
that
you
create,
which
I
can
talk
about
when
we
get
to
that.
B
B
By
the
way,
if
anyone
is
interested
into
even
deeper
dive
of
kind
of
what
I'm
doing
now
is
yesterday,
cora
gave
a
talk
on
kpac
and
tce,
but
also
went
through
a
lot
of
like
the
entire
cloud
native,
build
packs
kind
of
ecosystem
and
and
how
we
got
to
where
we
are
today,
and
I
recommend
taking
a
look
at
that.
If
it
actually
looks
like
there's
a
link
in
the
hackmd,
so
definitely
worth
checking
that
out.
Okay,
so
we
have
our
kpac
package.
B
These
are
the
only
two
pods
that
run
for
kpac,
like
our
controllers
and
our
web
hook,
and
next
we're
going
to
start
creating
some
of
the
resources
that
are
are
needed
to
run
kpac.
So
we
have
cluster
store.
Cluster
store
is
effectively
a
store
for
for
build
packs
that
are
referenced
by
builders
and
there
they're
used
to
actually
execute
these
builds
on
on
the
cluster.
B
There's
build
packs
for
a
ton
of
different
languages
and
you
can
also
write
your
own
build
packs,
but
the
the
method
for
which
you'd
add
them
in
kpac
is
actually
creating
something
called
a
cluster
store.
So
I'm
going
to
run
kp
cluster
source,
save
there's
also
create
command,
but
save
does
create
or
update.
So
it's
a
little
bit
easier
and
I'm
going
to
pass
in
one
build
package.
B
The
I'm
using
the
picado
build
packs
project
and
I'm
going
to
pass
in
the
go
build
pack.
I
could
have
left
off
the
digest
at
the
end.
But
for
later
in
my
demonstration,
I
wanted
to
pick
a
specific
version
of
the
build
pack
for
us
to
add
to
the
store
and
what
it's
going
to
do
now
is
is
relocate
the
build
pack.
B
I
went
ahead
and
relocated
these
earlier
just
to
save
some
time
on
the
relocation,
because
I
find
the
project's
registry
isn't
always
the
fastest
with
like
the
relocation,
but
that's
pretty
much
the
process,
and
if
we
looked,
we
could
see
kp
cluster
store
status
default
and
see.
We
have
our
our
paquetto
go,
build
pack
version
0,
13
0,
which
is
not
the
latest
version,
but
and
its
status
is
ready.
B
So
we'll
continue
on
to
our
next
resource,
which
is
a
cluster
stack.
The
cluster
stack
provides
two
images:
it's
the
run
image
and
the
build
image
which
kind
of
make
up
the
base
operating
system
for
our
images.
So
the
build
images
is
what
actually
the
builds
are
executed
on.
It's
the
base
os
for
the
builds
and
then
the
run
images
is
a
much
much
smaller
image
that
only
kind
of
has
what
you
need.
B
This
is
the
equivalent
of,
if
you
do
like
a
dockerfile
build
and
you
like,
have
a
build
image,
and
then
you
reference
it
when
you
actually
like
copy
say
like
the
jar
out
into
your
your
final
image
and-
and
it's
really
just
to
one-
have
a
smaller
image.
So
it's
easier
to
pass
around
and
two
minimize,
you
know
like
attack
vectors
in
packages,
so
we
want
the
least
amount
of
packages
we
can
get
into
the
final
image
where
it's
still
runnable.
B
So
I'm
going
to
create
a
cluster
stack
and
I'm
going
to
run
it
on
what
is
called
the
tiny
stack
from
the
pocketo
build
packs
project,
and
this
is
a
very,
very
small
footprint
stack.
It
only
supports
a
few
languages.
I
think
it
supports
java
go
java
native
image
and
maybe
one
other-
and
I
purposely
picked
version
1
318,
which
is
a
couple
versions
old
for
later
in
my
demonstration.
D
B
D
B
So
kpac
is,
is
a
collection
of
custom
resource
definitions
and
controllers
that
allow
you
to
build
oci,
compliant
container
images
for
your
application
so
like
source
to
image.
It's
it's.
Basically,
a
platform
implementation
of
the
cloud
native,
build
packs
project,
running
natively
on
kubernetes
there's
also
the
cloud-native
build
packs
project
has
like
the
pax
cli
for
you
to
execute
the
same
types
of
builds
locally
on
your
machine,
but
this
is
designed
to
be
run
at
scale
and
you
can
have
a
lot
of
users
doing
this
at
the
same
time.
C
B
Yeah,
so
I
think
the
reason
you
would
care
about
that
is
as
just
like
an
industry.
Everything
is
kind
of
moving
towards.
You
have
a
lot
of
services
that
you
want
to
deploy
on
a
cluster,
as
opposed
to
like
setting
up
a
one-off
vm.
That's
gonna
like
run
your
jar
file
and
you,
like
you,
know,
wrote
some
script.
B
B
Check
that
out-
and
it
is
ready
and,
as
you
can
see,
we-
we
did
relocate
these
images.
These
originally
lived
in
the
kettle,
build
packs,
docker
hub
and
now
they're
living
in
my
private
registry,
so
we
don't
have
to
worry
about
if
docker
hub
is
up
or
anything
like
that,
it's
in
our
registry
now
and
it's
kind
of
under
our
control.
B
So
the
next
thing
we're
going
to
do
is
create
a
cluster
builder
and
a
cluster
builder.
Is
it's
a
few
things
it?
It
contains
our
stack.
It
contains
our
build
packs
and
the
bil,
so
it
knows
which
build
packs
to
use
we.
It
has.
This
thing
called
an
order
which
will
define
in
which
order
we
attempt
to
run
our
build
packs
and
I'll
show
you
the
status
of
the
cluster
builder,
where
it
will
actually
break
down
exactly
how
those
build
packs
will
be
applied,
and
it
also
contains
what's
called
the
life
cycle.
B
The
life
cycle
is
like
your
standard
implementation
of
the
cloud
native,
build
packs
project
where
it
has
multiple
stages
that
will
run
and
execute
a
container
build.
So
it
will
take
the
source.
It
will
run
every
build,
pack
has
what's
called
a
detect
phase
and
a
build
phase.
It'll
run
the
detect
phase
for
every
single
build
pack
against
the
source
to
determine.
B
So
that's
that
all
that
code
for
the
lifecycle
also
lives
in
the
builder.
So
the
builder
itself
is
an
image
and
how
you
create
a
cluster
builder.
Is
you
just
give
it
a
name,
a
tag
where
it's
going
to
live
because,
like
I
said
it's
an
image,
a
stack
and
a
store,
and
then
this
dash
dash
build
pack
is
actually
me
defining
the
order.
B
If
I
had
more
build
packs
in
my
store,
I
could
provide
more
build
packs
or
I
could
say
I
have
50
build
packs
in
my
store,
but
I
only
want
this
builder
to
be
a
go
builder,
so
I'm
only
going
to
provide
this
cluster
builder
with
the
go,
build
packs
to
keep
it
small
and
keep
it
dedicated
for
what
I
want
to
use
it
for
it.
It
allows
you
to
have
that
kind
of
flexibility.
B
So
we
have
it's
already,
and
this
is
where
it's
living
and
then
I
pass
in
the
go
build
pack,
but
the
go.
Build
pack
is
actually
multiple
build
packs.
It's
what's
called
a
meta
build
pack,
so
it
creates
this
order
whenever
it
runs
now,
it
is
gonna
execute
one
build
pack
and
you
know
after
another
and
figure
out
which
ones
are
going
to
participate.
B
So
the
next
thing
we
have
to
do
is
is
create
a
secret
for
the
actual
image
that
we're
going
to
create
to
use
to
be
able
to
publish
to
the
to
the
registry
of
our
choice
during
the
export
phase,
I'm
going
to
be
pulling
from
a
public
github
repo,
but
if
it
was
a
private
one.
I
would
also
at
this
point
create
a
secret
to
pull
my
private
git
source.
B
You
could
also
use
a
blob
image,
a
registry
image
and
then,
if
you're,
using
the
kp
cli,
you
can
actually
upload
like
a
local
path
source
like
if
I'm
just
working
locally
on
my
project.
I
can
just
upload
my
my
source
directly.
It
doesn't
have
to
be
committed,
yet
maybe
one
other
thing
to
call
out
is:
I
mentioned
the
pax
cli
before
and
that
allows
you
to
execute
builds
locally.
You
can
actually
take
any
builder
from
kpac
and
use
it
in
the
pax
cli.
B
So
we're
going
to
create
an
image
with
this
tag,
we're
going
to
pull
from
the
paquetto
build
packs
samples
project
at
this
particular
git
revision
and
the
sub
path
is
just
where
in
the
repo
I
actually
want
to
build,
because
this
repo
has
a
whole
bunch
of
code
in
it
with
my
cluster
builder
and
then
dash
dash.
Wait
is
going
to
actually
wait
for
the
entire
build
to
execute.
B
B
B
And
if
we
look
here,
we
have
one
image
that
got
a
little
a
little
cut
off
there,
because
my
font
size,
but
the
important
thing
to
see
here
actually
is
this
reason.
So
the
reason
this
build
build
number
one
executed
was
configuration.
I
actually
just
created
the
resource,
so
it
always
does
an
initial
build
on
configuration
of
the
resource.
B
But
what
if
I
want
to
patch
an
image
I
say,
there's
a
new
commit
that
I
just
pushed,
and
I
want
to
build
that
I
can
run
a
kp
image,
save
passing
this
new
revision
and
it
should
automatically
kick
off
a
new
build.
And
if
you
see
here,
the
reason
is
actually
commit
now,
because
it
has
detected
a
change
in
the
source.
B
There
is
a
way
to
just
have
it
monitor
a
branch,
but
we
typically
recommend
like
doing
git
revision,
and
you
would
do
something
like
you
push
a
commit
to
the
repo,
maybe
run
some
unit
tests
and
then
in
ci
do
a
kp
image
patch.
We
also
have
a
concourse
resource.
You
can
use
to
patch
that
and
then
build
your
image,
so
maybe
do
like
a
little
pre-test
thing
before
as
part
of
your
your
development
workflow.
B
B
B
B
So
this
would
simulate
if,
if
there
was
a
cve
and
go
and
the
paquetto
team
released
a
new
version
of
the
build
pack,
we
want
to
make
sure
our
applications
get
updated.
You'll
know
it
does
have
to
go
through
a
full
rebuild
process
because
we're
actually
trying
to
change
the
application
source
code.
What
I'm
going
to
demonstrate
next
is
actually
like
what
I
would
consider
one
of
the
more
powerful
features
of
kpac,
which
is
rebasing,
so
how
we
we
have
what's
called
like
avi,
compliant
images
and
and
what
that
means
is.
B
Basically,
if
there
is
an
update
to
the
underlying
os,
say,
ubuntu
is
patched
with
a
critical
cve
and
I
have
50
apps
50
images
that
are
being
built
using
that
base
os,
and
I
want
to
patch
all
of
them
in
traditional
dockerfire
lan
dockerfile
land.
You
would
have
to
rebuild
all
you
have
to
change
your
from
statement,
and
that
would
because
that's
changing
the
base
layer
of
the
from
everything.
After
that,
every
single
layer
has
to
be
rebuilt.
B
B
B
So
it
ends
up
being
incredibly
fast.
And
if
you
look
here,
it's
going
through
a
rebase,
so
it's
going
to
load
the
secret
and
then
that's
it
it
just
it
all
it
does.
Is
it
takes
the
layer
for
the
new
os
slaps
it
underneath
the
old
one
and
then
pushes
that
as
a
new
image,
and
it
can
do
that
for
thousands
of
images
at
once.
If
you
have
a
very
large
deployment,
so
that's
something
that
allows
you
to
keep
your
images
up
to
date
against
any
like
critical,
vulnerabilities
or
stuff
like
that.
A
A
They're
definitely
been
a
couple
of
threats
going
on
in
the
chat
and
we
are
running
low
on
time.
So
how
can
folks
find
you
if
they
need
to
connect
with
you
after
this?
So
you,
I
imagine,
you're
in
our
slack
channel
that
folks
can
post
questions
I'll,
let
you
yep
yep,
yep,
okay,
and
do
you
all
have
any
like
other
resources
that
you
want
to
turn
people
to
some
docs
or
a
link
to
this
demo,
or
something
like
that?