►
From YouTube: Building Container Images on Your Kubernetes Cluster with Knative Build - Gareth Rushgrove, Docker
Description
Join us for Kubernetes Forums Seoul, Sydney, Bengaluru and Delhi - learn more at kubecon.io
Don't miss KubeCon + CloudNativeCon 2020 events in Amsterdam March 30 - April 2, Shanghai July 28-30 and Boston November 17-20! Learn more at kubecon.io. The conference features presentations from developers and end users of Kubernetes, Prometheus, Envoy, and all of the other CNCF-hosted projects
Building Container Images on Your Kubernetes Cluster with Knative Build - Gareth Rushgrove, Docker
One of the components of the recently released Knative project is Knative Build. This introduces the Build and BuiltTemplate objects to the cluster, meaning you can build images and then push them to a registry, all from within your Kubernetes cluster. In this talk we will: * Introduce the new API objects and show how they can be used * Convert an existing project from an existing CI system over to Knative Build, including building source code, running tests and pushing to a container registry * Look at some of the existing build templates using Kaniko, Docker, Buildpacks and more * Show how to write your own build templates and build images * Compare the current workflow with that of different CI systems to better understand what might be built next
To learn more: https://sched.co/GrSt
A
Okay,
I
think
we're
ready
to
go
wake
everyone
up
in
the
morning.
Okay,
so
I'm
here
to
talk
about
building
container
images
on
your
cluster
with
Kenna
to
build
so
hopefully
you're
here
for
that
talk,
I'm,
Gareth,
I'm,
garish,
Grove,
I
work
at
docker
as
a
product
manager
and
predominately
on
developer,
facing
tools.
You
can
pretty
much
find
me
in
most
places
on
the
internet
as
Gareth,
so
I'm
going
to
talk
about
I
know
like
to
start
with
I'm
going
to
talk
about
the
user
problem
that
they
all.
A
Why
do
you
want
to
build
on
your
cluster
in
the
first
place?
And
it's
always
nice
to
have
new
shiny
technology,
but
what's
the
problem
you're
trying
to
solve
once
we
get
that
other
way,
I'll
wax
lyrical
about
like
why
custom
Resources
Inc
you
Betty's
over
honking
great
idea,
introduce
kinetic,
build
and
talk
about
partially.
Why
you
shouldn't
do
a
lot
of
the
things?
I'll
show
you
and
then
what
you
can
do
instead
and
while
we
speculate
about
what
might
happen
in
the
future,
so.
A
One
of
the
things
that
I
want
to
start
with
is
just
like
your
CI
systems,
your
build
systems,
our
production
like
where
often
they're,
like
even
in
environments,
when
you've
really
thought
about
production.
You've
thought
about
security,
you've
thought
about
who
has
access
to
what
and
how
you
might
be
compromised
and
the
build
system
ends
up
as
it's
all
an
afterthought.
A
Oh
it's
over
there
and
everyone
has
access
to
it
and
we
have
a
shared
like
Jenkins
SSH
key
CI
systems
are
production
they're
a
rate
great
way
of
someone
compromising
your
system,
that's
probably
less
defended
than
your
front
door.
So
thinking
about
cluster
builds
is
a
one
way
of
sort
of
well
actually
bringing
your
build
pipeline
to
production.
A
Lots
of
people
maintain
really
wildly
different
types
of
machines
for
their
CI
system
as
well.
Again,
sometimes
it's
even
different
people.
It's
not
given
the
same
weight
and
as
your
crown
jewels,
your
database
servers
or
whatever
it
might
be
an
autumn.
Utley,
less
variation
of
the
infrastructure
to
manage
can
only
be
a
good
thing
from
the
point
of
view
like
the
cost
of
managing
it.
A
And
fundamentally,
software
build
is
a
scheduling
problem
and
it's
all
about
there's
some
compute
that
you
want
to
run
run
in
a
specific
order
and
you
want
that
to
run
as
quickly
as
possible
and
who
likes
waiting
for
their
software
build
process
to
finish
and
if
you
can
take
advantage
of
committees
or
ugly,
a
scheduler
across
a
cluster.
Your
builds
are
going
to
go
faster,
you're,
going
to
have
better
utilization
everyone's
happy
so
building
on
the
cluster,
like
has
a
bunch
of
advantages
like
we
can
reduce
our
operation
overhead.
A
A
Look
what
I
got
to
do
with
kubernetes
and
how
do
we
bring
that
into
karate
world
who,
in
the
room,
is
like
either
installing
or
writing
custom
resources
for
gratis
scouring
of
hands?
I'm
gonna
go
like
5%
of
the
room
so
like
I
know.
Ultimately,
kubernetes
gives
you
an
API
argument.
It
gives
you
too
much
in
the
API
there's
three
four
hundred
or
so
API
objects.
You
probably
care
about
a
smaller
number
of
those.
These
are
the
pods
replication
controllers
deployments
all
the
bits
that
you
solve,
probably
familiar
with.
A
If
you've
been
using
communities
now
with
custom
resources,
you
can
extend
that
API,
you
can
add
new
objects,
and
that
might
be
very
specific
things
for
your
organization
or
it
might
be
things
where
we
have
a
general
problem
or
a
subset
of
us
have
a
specific
problem.
Customer
resources
come
in
a
couple
of
flavors
with
CRTs
and
API
servers,
and
there
are
sort
of
trade-offs
the
documentation
around.
This
has
got
really
good
recently.
So
there's
a
good
explanation
of
where
you
might
start,
but
most
of
that's
about.
A
A
So
well,
if
we've
got
a
user
problem
and
extending
kubernetes
is
actually
both
possible
powerful
and
a
really
good
idea,
where
does
care
to
build
come
in
so
can
its
build,
is
part
of
the
wider
set
of
creative
projects
and
it's
arguing
of
a
sort
of
small
part,
but
I
think
it's
probably
very
generally
applicable
and
ultimately
it's
a
CR
D.
It's
customer
resource
definition,
which
adds
a
small
number
of
primitives
to
kubernetes
for
modeling
the
software
build
process.
A
So
if
you're
used
to
using
kubernetes
and
deployments
and
services
and
other
parts
to
model
an
application
that
you're
running,
this
is
about
modeling.
Well,
how
you
built
the
application
in
the
first
place,
it's
obviously
available
on
github,
ok
native,
slash,
build
again
all
open
source
in
very
active
development
at
the
moment,
and
I'll
come
back
to
some
of
that
a
bit
later
as
well,
but
you
can
get
started
from
there.
Alright
again,
installing
custom
resources-
and
this
is
true
of
all
of
them
connected
build-
is
no
different
they're
just
installed
via
the
communities
API.
A
It's
not
different
to
you
running
any
other
workload
on
top
of
kubernetes,
so
you
can
install
obviously
blithely
grabbing
a
URL
from
the
internet
and
keep
CTL
apply.
I
might
not
be
always
a
good
idea,
but
like
we'll
trust
it
for
the
moment,
so
what
happened?
Obviously,
you
would
go
and
read
that
long
file
before
you
did
that
and
you
would
know
this
was
coming,
but
in
this
case
like
what
did
we
get
out
of
installing
can
I
build
I'm,
actually
a
really
small
number
of
things
which
I
think
he's
good.
A
But
what
they
did
was
add
new
primitives
to
kubernetes,
so
whether,
however
you're
interacting
with
the
communities
API,
maybe
you're
just
doing
coop
CTL
like
get
pods
well
now
you
can
do
get
build
and
get
build
template.
So
a
build
only
is
this
is
that
this
is
what
we
still
call
that
the
individual
build.
So
every
time
you
do
a
like.
Every
time
you
build
your
software,
that's
a
build!
It
can
include
multiple
steps
in
there.
So
maybe
you
have
a
step
for
building
an
image.
Maybe
you
have
a
step
for
testing
it?
A
Maybe
you
have
a
set
for
linting
the
source
code,
whatever
it
might
be.
Builders
are
an
implementation
detail.
They're
around,
like
each
step,
is
basically
run
as
a
container
within
the
pod
and
build
templates
I'll
come
on
to
a
really
a
way
of
making
like
builds,
parameterize
herbal
and
much
more
reusable,
and
it
ties
in
it's
just
a
workload
running
in
communities.
So
all
of
the
other
things
are
there
around
I
in
service
accounts
and
tying
into
secrets
where
you
need
maybe
for
pushing
an
image
to
a
repository,
for
example.
A
So
a
word
of
warning
before
anyone
walks
out
after
the
next
few
slides
going
like
this
is
a
bit
crazy
and
capabilities
is
ultimately
pretty
low-level.
It's
for
tool,
builders
to
build
on
top
of
and
I
think
it's
interesting
to
look
at
how
it
works,
and
so
I'm
going
to
run
through
that
I'm
going
to
come
back
to
some
higher-level
tools
that
people
are
starting
to
experiment
with
and
build
on
top.
A
So
just
a
word
of
warning,
so
thanks
to
Seb
I,
don't
if
he's
in
the
room,
but
he
had
this
salt,
hello
world
example
and
I
just
thought.
This
was
a
useful
one
to
show,
and
this
is
again
later
remember:
we've
extended
the
communities
API
we've
added
build,
so
we've
got
kind,
build
and
we've,
given
this
a
name
like
lots
of
other
resources
and
we've
defined
a
series
of
steps
or
a
rather
one
step
and
all
that's
doing.
Is
it's
using
a
certain
image
and
passing
some
arguments?
A
It's
obviously
that's
not
actually
doing
anything
to
do
it.
Software
build,
it
is
just
gonna,
bring
the
nation
and
again
that's
up
to
the
warning
and
if
you're
thinking,
Oh
brilliant
I
can
take
whatever
build
process.
I
have
today
and
write
a
million
documents.
Don't
do
that
please!
This
remember
is
the
API
payload
and
it's
useful
to
understand
what's
going
on
at
that
level,
but
it's
not
a
user
interface.
A
Running
that
and
we
can
again
we're
at
the
API
level
we
can
just
apply
that
document
well
will
will
create
a
build.
We
can
get
that
back
and
we
can
see
the
pods
we
can
get
the
logs
from
the
pods
in
this
case
away
brand
builder
successful.
It's
not
very
exciting
example,
but
it's
just
like
everything
else.
You
do
with
kubernetes.
A
It
gets
a
lot
more
interesting
when
we
start
introducing
build
templates,
so
I
say:
build
templates
are
a
way
of
bringing
someone
of
some
opinions
and
starting
to
build
a
more
approachable
user
interface.
I,
don't
want
to
specify
every
time
I
do
a
build.
All
of
the
steps
required
for
that
build,
especially
as
I
might
have
I
know
hundreds
of
different
projects,
all
with
very
similar
needs.
A
So
there
are
a
set
of
build
templates
in
that
repository
in
the
creative
project
repo
and
at
the
moment,
there's
ones
for
the
basil
build
tool.
Jib
build
pack
spill
kit
builder
can
occur
at
the
moment
most
of
the
interest
around
this
been
from
basically
people
who
build
build
tools
which
gets
pretty
meta
pretty
quickly.
That
was
partly
how
I
sort
of
got
involved
and
ultimately,
I
think
it
will
get
much
more
interesting
with
like
higher
level
templates.
A
Some
of
those
will
be
specific
to
your
organization
and
your
projects,
but
I
think
there's
also
a
lot
of
potential
to
have
I'm
per
framework
type
templates.
Ultimately,
if
you're
having
it
off
the
shelf,
Django
or
Rails
or
react
template
and
would
actually
be
a
probably
I,
would
argue
a
lot
more
useful
than
the
just
pure
sort
of
generic
build
tool.
Templates
you'll
end
up
building
on
top
of
those,
but
that's
different.
A
Build
templates
again:
we've
just
creative
builders
added
build
template
to
kubernetes,
there's
a
new
object.
We
can
apply
again
like
even
more
arbitrary
code
from
the
internet
and
we've
got
build
templates
there,
and
but
let's
look
a
little
bit
under
the
hood
about
what
are
those
things.
So
a
built
template
breaks
down
into
two
main
areas
and
again
this
is
the
sort
of
wire
format.
A
We've
got
a
series
of
parameters,
so
this
is
just
saying:
well,
some
things
about
our
build
are
going
to
need
to
be
different
between
different
builds.
What
do
we
need
to
inject
in
in
this
case
we're
injecting
in
a
path
for
a
naka
file
and
and
the
image
name
and
we've
set
a
default
for
the
doc
file,
so
very,
like
simple,
high-level
bits,
but
you
could
parameterize
your
builds
with
anything
you
want
and
we're
specifying
a
series
of
steps,
or
in
this
case
a
single
step.
A
Partly
so,
if
it's
on
the
slaughter
side-
and
you
can
see
here
both
of
those
variables-
the
parameters
are
actually
available
to
that
build
step
is
basically
environment
variables.
So
here
we're
saying
well,
building
push
use
this
execute
to
use
this
builder
and
that's
just
a
container
and
wit,
and
that's
going
to
get
past
the
source
code
run
and
run
with
those
arguments.
A
So
now
that
we've
got
a
template
now,
we've
got
a
series
of
templates
and
we
can
instead
of
having
to
specify
every
time
like
we
want
to
build
all
the
steps
we
now
just
say.
Oh
no
just
use
that
template
over
there-
and
here
is
the
argument
so
and
if
you
look
through
here
realistically
whoops
and
there's
not
an
awful
lot
of
thing
like
there's
a
lot
of
lines
there,
but
most
of
that
is
boilerplate
again.
This
is
for
computers
rather
than
people.
But
really
all
we're
saying
is
oh
use.
A
A
And
again
we
can
run
that
we
can
here
grab
the
pod
identifier
from
basically
the
output
from
the
build
it's
buried
in
there.
So
you
end
up
sort
of
jumping
around
again
this
isn't.
This
is
a
low-level
like
API,
really
more
than
a
UI,
and
we
can
grab
the
logs
and
you
would
see
it
actually
just
running
the
build.
It
was
you'd,
see
it
running
in
this
case
kind
of
CO
or
build
care,
or
whatever
builder
you're,
using.
A
But
there
is
there
are
people
starting
to
build
on
top
of
it
and
that's
what
it's
for
it's
for
people
to
start
actually
being
able
to
innovate
on
in
in
and
around
software,
build
and
CI
systems
and
in
a
way,
that's
sort
of
decoupled
from
having
to
also
do
a
load
of
hard
work,
around
scheduling
and
low-level
primitives.
So
I
think
one
of
the
things
that
might
come
out
of
the
chaotic
build
is
actually
just
an
explosion
of
different
approaches
to
software.
A
So
some
of
this
comes
from
I.
Think
that,
like
this
community
is
a
really
sort
of
interesting
mix
of
system
engineers
for
whom
actually
they're
going
like.
Why
does
it
used
to
keep
saying?
Don't
do
that?
That
sounds
great
to
me
and
end
users
who
are
like
this
is
madness?
What's
going
on
we're
all
here
in
one
place
and
I?
Think
that's
really
interesting
and
having
projects
like
Canada
to
build
that
provide
the
primitives
for
other
things
to
come
on
top
that
benefit,
end-users
is
sort
of
I.
A
Think
it
is,
is
occasionally
a
weakness
because
we
geek
out
about
the
low
level
and
we
write
API
wire,
fall
out
documents,
but
I
think
it's
a
huge
strength
for
the
flexibility
and
sort
of
power
of
the
platform
so
can
active
build
is
for
those
people
building
the
systems.
What
about
like
the
end
users?
What
about
people
who
actually
just
want
to
build
some
software
and
say
there's
a
number
of
different
things
going
on
at
the
moment?
A
I
think
some
of
this
will
end
up
coalescing
together
in
one
place,
I've
been
doing
some
experiments
around
build
templates,
so
you
saw
those
like
documents
with
build
templates
and
they
can
get
quite
big
I
mean
if
you've
got
a
software
build
process
that
has
like
a
lot
of
steps.
Seven,
eight,
nine
ten
steps,
if
you're
parameterizing
in
such
a
way
that
it
really
is
reusable
across
a
large
number
of
projects,
maybe
even
outside
your
organization.
A
Those
things
can
get
complex
and
I'm,
actually
just
passing
them
as
a
as
a
yama
document
or
anything
isn't
that
useful,
but
as
a
user,
you
do
want
to
know
well
that
that
template
is
a
user
interface.
That's
been
described
for
you
to
use
so
I
think
that
I
will
probably
end
up
pushing
this
somewhere
else.
It's
a
bit
of
a
sort
of
proof
of
concept.
A
So
TM
I'll
show
a
quick
demo
of
that
in
a
moment
as
well,
but
again
is
a
tool
for
all
of
K
native
badgy
worked
really
well
just
with
the
build
stuff
as
well.
So
here
we
start
seeing
that
like
a
higher-level
approach
to
the
problem,
so
instead
of
writing
a
document
that
you
will
send
to
the
API
and
every
time
you
want
to
do
a
build
well,
we
can
just
like
I'm
in
this
case
sort
of
deploy
sort
of
odd
verb,
but
make
sense
in
the
context
of
finish
as
a
whole.
A
Here
we
deploy
a
build
I'm,
calling
it
coop
Val.
That's
one
of
the
tools.
I
maintain
I'm,
saying
the
source
code
is
over.
There
I'm
saying
use
this
build
template,
and
oh
by
the
way,
the
arguments
I
want
to
change
from
any
of
the
defaults
are.
The
image
name
should
be
Gareth
our
law
school
bell
and
that
will
ultimately
that
will
generate
that
document.
Send
it
to
the
API
like
that,
will
do
everything
for
you.
A
You
don't
have
to
write
a
document
to
disk
and
then
send
something
and
trigger
measure
also
have
a
the
Tim
command.
Has
a
high
level
interface
for
getting
data
back
about
the
bills?
It
doesn't
I,
don't
think,
have
the
shortcut
to
get
the
logs
yet,
but
I
think
that
would
be
a
nice
addition.
So
we
can
just
get
the
build
date.
Details
in
there
you'll
see
the
steps.
They've
run
the
white.
A
What
succeeded
again,
not
the
output,
that's
in
the
logs
and
it
would
be
sort
of
gotta
be
able
to
go
straight
from
here
to
the
longest,
but
another
really
interesting
project
in
this
space.
That's
actually
starting
to
use
K
native,
build
under
the
hood
and
for
all
the
reasons
that
we've
described
it's
like.
Oh,
this
is
doing
a
lot
of
the
heavy
lifting
around
just
like
running
workloads
on
committees.
For
software,
build
is
Jenkins
X,
so
the
cloud-based
folks
are
around.
A
This
is
a
like
letting
quite
a
lot
of
work
at
the
moment
to
like
have
both
brow
and
Kelly's
build
run
under
the
hood
here,
and
this
provides
you
with
the
Jenkins
interface
to
this
I'm.
So
you
can
still
use
your
Jenkins
files
and
some
of
the
other
new
UI
bits,
they're
working
on
and
I've
been
playing
with.
A
You
just
copy
that
into
a
very
thin
like
scratching,
Mia
jar,
a
small
Alpine
image
or
whatever
that
doesn't
have
the
build
tools.
You've
got
a
small
out
image
at
the
end
and
the
surface.
The
tack
surface
area
is
great.
That's
probably
99%
at
the
moment
of
the
multi
se
build
examples
I
see,
but
you
can
do
a
lot
more
here.
So
actually,
this
this
example
is
from
a
bigger
example
and
I'll
show
you
the
URL
and
a
second,
where
I'm
actually
just
running
the
tests.
A
I
have
image
it
like
builds
in
the
multistage,
build
for
running
the
tests.
I
have
like
checks,
and
this
is
a
Python
application-
that
checks
the
sort
of
security
things
running
the
Aqua
micro
scanner,
double
checking,
like
other
known
security,
vulnerabilities,
I,
just
started
playing
with
this
convention
of
like
capitalizing,
some
of
the
build
stages
so
test
check
security
here,
as
they
basically
a
sort
of
cause,
I
interface
saying
oh
yeah.
A
These
are
public
if
you
like,
and
then
automatically
generating
the
chaotic,
build
steps
and
because,
if
you
look
at
this,
this
is
hugely
repetitious
and
the
only
things
that
vary
are
the
things
I
get
extracted
from
my
docker
file.
So
you
can
have
a
docker
file.
You
can
just
run
local
builds
on
a
single
docker
like
engine,
but
you
can
also
expand
that
out
into
an
entire
build
pipeline.
Inc
a
native.
A
You
can
see
some
of
these
examples
in
this
repo
as
well.
There's
there's
other
things
there
around
expanding
that
into
both
github
actions
and
other
sort
of
platforms.
Yeah,
it's
not
it's,
not
a
general
solution
to
sort
of
arbitrary
complex
builds,
but
actually
they're
sort
of
having
some
like
just
humming
the
UI
for
doc
file
and
expanding
it
into
sort
of
all
the
different
platforms.
It's
sort
of
quite
interesting,
I'm
playing
with
at
the
moment.
A
A
I
said
like,
and
you
can
have
quite
complex,
build
templates,
and
this
is
actually
something
that
I
mechanically
generating
from
that
doc
file
trick,
but
it
didn't
need
to
be
that
sort
of
sort
of
relevant
and
I
am
just
using
this
locally
I've
got
a
local
committees
installed
with
dr.
desktop
and
I've
got
the
socket
mounted
and
obviously
you
know
closed
the
situation.
That's
not
a
good
idea,
but
it's
handy
locally,
because
then
you
I'm
building
on
my
cluster
but
I
have
access
to
it
from
all
my
other
tools
as
well.
A
Yeah,
there's
a
whole
bunch
of
steps
in
here,
I'm
running
well,
I'm,
running
tests,
I'm
running
checks,
I'm
running
structure
tests,
which
is
basically
an
acceptance,
testing
thing
for
images
and
finally,
I'll
I'll
build
and
push
well.
Luckily,
an
image
so
yes,
I
could
I
could
create
a
build
file.
I
could
do
it
manually
and
it's
much
easier
with
some
of
the
high
level
tools.
So
here
I'm
doing
Tim
replay,
build
I'm
gonna
call
my
build
multi
I'm.
The
source
code,
for
this
is
that
roof
I
showed
you
previously
I'm
using
that
template.
A
So
I
know
this
is
one
of
the
areas
where
we'll
see
high-level
tools
and
doubtedly
emerge,
and
some
of
this
will
then
be
abstracted
even
further
away
from
you
from
for
things
that
aren't
actually
about
Katie
to
build
they're
about
Jenkins,
X
or
similar.
But
it's
useful
to
saw
see
what's
going
on.
Okay,.
A
So
just
getting
blogs
from
the
top
level
from
the
pod
itself
will
sudden
I
see
the
love
there.
Builded
we're
successful
and
I
had
a
bunch
of
stuff
cash
so
around
pretty
quickly,
but
we
can
also
get
their
logs
for
the
individual
steps.
So
you
get
build
step
question
which
steps
if
I
go
in
there.
So
the
step
names
are
like
these
bits
here,
so
build
check
test.
A
A
So
that's
sort
of
like
pretty
quick
run-through
of
where
things
stand
now.
Barry
is
a
pretty
new
project.
I
think
it's
already
really
interesting,
especially
if
you're
like
interested
in
building
like
new
or
and
even
existing
sort
of
build
tools.
I
think
the
future
is
going
to
be
even
more
interesting,
so
I'm
Katie
have
sort
of
came
out
and
there
were
a
small
number
of
people
have
been
working
on
it
ahead
of
time
and
I.
A
A
There
is
a
lot
of
there's
a
lot
of
discussions
on
and
on
in
design
documents
actually
about
some
of
the
is
this
actually
just
the
right
abstraction.
Is
this
a
right?
Api
object
this
all
of
these
alpha
in
the
CID
things
will
change,
and
one
of
the
big
changes
coming
is
actually
around
a
new
CID
which
is
build
pipeline,
and
this
is
even
newer.
A
You
need
you
can't
and
there's
not
even
an
installation
mechanism
that
just
for
users
files
from
the
internet,
yet
you
need
to
hold
go
tool
chain
to
get
this
up
and
running,
but
that's
changing
pretty
rapidly.
This
is
really
bringing
the
concept
of
that
pipeline
as
a
first-class
bike.
Pod
of
kubernetes,
so
build
is
interesting.
You
had
a
series
of
steps,
but
actually,
if
you
want
to
describe
arbitrary,
complex,
build
processes,
you
probably
need
some
concept
of
well
actually
how
these
things
relate
and
the
graph
and
that's
what's
happening
with
build
pipeline.
A
That
will
definitely
change
like
the
low-level
bits
that
we've
seen
so
do
get
involved.
If
this
is
your
sort
of
thing
actually
I
think
their
map
just
wanders
up
and
said
hi
sir
who's
around.
If
you
want
to
talk
about
that
with
them,
so
it's
early
like
it's
definitely
for
sort
of
tool.
Builders
but
I
think
there's
a
lot
of
things
going
on
that
interest
me
at
least
I
think
it's
interesting
to
speculate
about
what
we
can
build
on
top
of
this.
These
might
all
be
great
things.
A
You
can
go
in
and
build
and
do
a
talk
about
next
coupon.
The
idea
of
a
unified
back-end
for
different
CI
systems
is
sort
of
interesting,
I.
Think
I.
Imagine
several
different
CI
systems
built
on
top
of
these
low-level
primitives
and
you
can
be
running
different
ones
in
different
places
without
quite
the
same
overhead
as
you
would
do
today,
and
maybe
different
teams
genuinely
need
different
types
of
interfaces
because
they're
building
different
types
of
things
and
right
now,
you'd
have
to
make
these
sort
of
trade
offs
where
it's
like.
A
Well,
ok,
but
you
have
to
maintain
separate
infrastructure,
separate
concepts.
The
whole
stack
separately,
that's
probably
far
too
much
of
an
overhead
and
you'll
probably
say
no.
You
have
to
use
this,
and
everyone's
like.
Oh
I,
want
to
use
this
and
by
sharing
all
of
the
backend,
be
by
sharing
all
of
that
those
low
level
of
primitives.
It
becomes
just
about
the
user
interface
and
maybe
then
there
are
arguments
for
having
different
user
interested
in
different
places
and
there's
some
level
of
compatibility
because
of
the
low-level
bits.
A
And
community
supports
different
changes
for
different
purposes.
It's
it's
I
think
like
not
used
that
much,
because
actually
a
lot
of
the
workloads
people
are
doing
a
similar
and
I
think
there's
sort
of
an
interesting
area
where
around
as
these
primitives
emerged,
like
are
they're,
arguing,
there's
more
specific
to
build
that
are
better
at
scheduling
those
types
of
workloads.
A
A
I
didn't
start
that
around
K
native
I
started
it
actually
around
generating
make
files
and
generating
other
user
interfaces,
and
then
Kennedy
build
copped.
Open
I
was
like
oh
well:
I
can
generate
that
then
get
all
action,
scope,
tip
and
I
generated
that
I.
Think
having
high-level
you
is
that
can
have
multiple
backends.
It's
not
interesting
and
I
mentioned
earlier
as
well.
A
I
think
the
and
the
build
templates
that
they're
at
the
moment
are
good
examples
and
but
they're
simple
and
they're
centered
on
the
build
tool,
they're
not
centered,
on
your
application
that
you're
building
and
I
think
I'd
love
to
see
language
communities.
I
think
this
is
true
in
lots
of
different
communities,
but
I
think
this
is
definitely
one
of
them.
That's
probably
lobe
re-entry
opinionated
like
per
language
per
framework
templates
like
if
you
know
all
the
the
rails,
people
are.
You
know
all
the
spring
boot
people
are
like,
whatever
framework
to
show
you
are
using.
A
Having
templates
for
those
like
imagine
just
having
that
out-of-the-box,
you
have
a
a
well
thought
through,
like
not
overly
complex
but
actually
powerful,
build
pipeline.
That's
just
the
default
for
your
framework
or
platform.
Of
course
you
can
change
that.
Of
course
you
can
like
do
your
own
thing,
but
I
think
that's
not
something
we
have
today
at
all
and
I
think
that
would
be
interesting
in
the
concept
of
these
build
templates,
which
is
I.
A
Think
one
of
the
interesting
bits
and
Kennedy
build
so
wrapping
up
like
and
if
all
you
take
away
really
is
and
Kennedy
build
is
for
tool.
Builders
is
the
low-level
bits
that
are
provided
there,
but
actually
it
has
a
lot
of
potential
for
like
a
lot
of
end-user
benefits,
so
I
think
is
worth
paying
attention.
A
So
if
you're
thinking
all
like
the
low-level
stuff
is
a
bit
like
off-putting,
like
actually
I,
think
the
best
thing
here
would
be
people
who
are
like
more
of
a
have
a
design
sensibility,
a
high
level,
not
just
gurus,
like
CLI
tools
as
well
and
just
in
general,
and
not
just
specific,
to
cater
to
build
and
custom
resources
are
brilliant
and
if
you're
not
aware
of
them,
have
a
look
and
look
for
opportunities
to
like
where
there
are
actually
either
very
domain-specific
or
community
specific
extensions
to
committees.
That
would
be
really
useful.