►
From YouTube: From PaaS to Kubernetes: Combining the Power of Kubernetes with the Most Innovative Features
Description
Want to view more sessions and keep the conversations going? Join us for KubeCon + CloudNativeCon North America in Seattle, December 11 - 13, 2018 (http://bit.ly/KCCNCNA18) or in Shanghai, November 14-15 (http://bit.ly/kccncchina18).
From PaaS to Kubernetes: Combining the Power of Kubernetes with the Most Innovative Features of PaaS - William Denniss, Google (Beginner Skill Level)
The PaaS application deployment model innovated by abstracting away the infrastructure layer and pioneered production deployments from version control – but at a cost of portability, and flexibility. This talk covers how to wire up Kubernetes to get the best elements of a PaaS like push-to-deploy, and infrastructure abstraction, while gaining the flexibility, portability and interoperability that Kubernetes offers. Topics covered will include ways to use Kubernetes without needing to be on-call (no more 3am phone calls!), and why it makes sense to start with Kubernetes, even for early-stage products using a single-node cluster. This presentation isn't about running a PaaS on Kubernetes or hiding the Kubernetes API from application developers, it's is about applying the best elements from the PaaS pattern, while keeping all the innovations and flexibility of Kubernetes.
About William
William is a Product Manager at Google on Google Kubernetes Engine. He chairs the Kubernetes Conformance working group, and has a passion for interoperability and developer experience. Previously he worked in the OAuth community, authoring RFC 8252 and creating AppAuth, the leading open source OAuth client for native apps. In 2017 he presented talks at DockerCon, Google Cloud Next Tokyo and KubeCon Austin.
Join us for KubeCon + CloudNativeCon in Barcelona May 20 - 23, Shanghai June 24 - 26, and San Diego November 18 - 21! 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.
A
Hi
everyone
and
welcome
to
my
talk
from
Pastor
kubernetes,
combining
the
power
of
kubernetes
with
the
most
innovative
features
of
paths,
I'm,
William,
Dennis,
a
product
manager
on
Google,
kubernetes
engine
and
I'm,
actually
going
to
be
live-tweeting.
My
own
talk
today
using
an
app
called
buffer,
so
you
can
follow,
along
with
this
hashtag
in
particular,
I'll
be
putting
links
to
the
source
code
to
the
demo
on
that.
So,
if
you
want
to
grab
that
link,
that's
an
easy
way
to
get
it.
A
A
You
know
just
out
of
ten
years
ago
now
and
they'll
very
revolutionary
at
the
time,
if
you're
unfamiliar
with
the
concept
Paz
stands
for
platform
as
a
service,
and
it
was
this
innovative
way
that
developers
could
kind
of
further
code
over
the
fence
and
have
a
platform
worried
about
executing
and
running
that
code
and
hosting
it
for
them.
Prior
to
that
model,
developers
typically
had
a
fairly
complex
setup,
where
they'd
have
to
configure
a
host
install
their
dependencies
and
packages
they
needed
and
then
deploy
their
code.
It
was
painful
enough.
A
Just
you
know
configuring
this
thing
and
even
and
then
once
you
had
done
that
the
code
was
kind
of
just
to
paint
a
deploy
as
well.
So
Paz
has
really
revolutionized
that
they
made
it
really
easy
to
get
started
and
they
introduced
this
model
of
like
git
push
to
deploy.
So
you
could
just
push
your
code
over
and
then
the
platform
would
handle
everything
for
you.
There
was
also
an
infrastructure
to
manage,
so
you
didn't
have
to
worry
about
machines.
A
What
makes
Kuban
ADEs
popular
today
for
some
of
those
same
use
cases-
and
this
is
not
a
comprehensive
list-
I'm
really
just
talking
about
that
kind
of
use
case.
One
of
the
most
important
ones
is
of
course
language
flexibility.
So,
whereas
the
pass
was
kind
of
tightly
coupled
with
the
language
up
to
the
point
where
it
may
even
in
be
injecting
code
during
deployment,
that's
specific
to
that
language
communities
by
running
containers,
you
can
run
anything
that
runs
container,
which
is
just
about
anything.
A
There's
also
a
lot
less
vendor
lock-in
as
I'm
sure
you
all
the
way.
Cumulus
is
open
source,
surprise,
surprise,
and
you
can
run
it
just
about
anywhere,
so
you're
not
tied
to
a
particular
vendor
or
a
particular
way
of
doing
things.
There's
also
some
very
nice
resource
optimizations
in
kubernetes,
because
you
can
bin
pack
a
whole
bunch
of
different
services
onto
a
shared
pool
of
resources.
And
no
one
does
that
save
you
money,
but
that's
also
open
the
door
for
some
new
ways
to
actually
build
applications.
A
It's
also
very
customizable,
so
you
can
build
your
own
pipeline
and
kind
of
configure
it
and
get
it
exactly
how
you
want
it
and
as
well
as
a
whole,
bunch
of
really
great
SAS
add-ons.
There
are
now
some
really
solid.
Open-Source
add-ons
as
well
like
Prometheus,
is
a
good
example
for
logging
and
of
course,
you
can
deploy
more
than
just
12
factor
applications,
so
you
can
deploy
stateful
applications
and
batch
workloads
and
whole
bunch
of
other
things.
A
Kubernetes,
as
you're
probably
aware,
is
a
workload
level
abstraction
and
but
what
I
mean
by
that
is
that
you
describe
your
work
user.
You
describe
your
deployment
as
a
set
of
workloads.
For
example,
I
want
ten
of
container
a
and
I
want
ten
of
container
B
and
I
want
them
say,
deployed
together,
because
Lancie
is
a
problem
or
I
want
them
spread
around
the
world
because
I
want
it
to
be
super
reliable
or
I
want.
Both
I
want
to
have
like
clusters
of
paired
services
spread
around
the
world
or
maybe
I'm
doing
something
completely
different.
A
Maybe
I'm
rendering
a
movie
and
I
want
to
render
it
one
frame
at
a
time
and
I
want
to
render
it
on
like
the
cheapest
CPU
possible.
So
I
don't
want
to
pay
for
like
the
office
shelf.
Vms
I
want
to
get
the
preemptable
z'.
Those
are
just
two
three
examples
of
what
communities
can
do.
You
can
really
represent
a
whole
lot
of
different
workloads,
which
is
extremely
powerful
and
I
personally,
like
the
fact
that
it's
built
on
this
declarative
style
architecture.
A
So
you
just
tell
it
what
you
want,
and
it's
kind
of
kubernetes
this
job
to
make
that
a
reality.
So
you
say:
I
want
10
replicas
upon
a
and
and
it's
kubernetes
his
job
to
make
that
happen.
Certainly,
you
can
observe
what's
going
on
and
check
it,
but
you
don't
have
to
actually
manually
into
being
too
much
I
like
to
think
that
community
sits
at
the
ideal
level
of
abstraction,
so
it
doesn't
go
to
low
levels,
so
you're
not
managing
machines,
just
the
same
with
a
pass,
but
it's
also
not
to
high
level.
A
A
So
really
it's
just
sitting
beautifully
between
the
infrastructure
and
the
application,
whereas
by
comparison
with
the
PA's
model,
there's
kind
of
this
intermingling
of
the
application
in
the
past
and
I
thought,
Brendan
Burns
said
it
pretty
well
last
week,
in
an
article
too
many
concepts
with
powers
were
mixed
into
a
single
monolithic
product.
It
was
kind
of
hard
to
separate
out
the
bits
that
you
wanted.
A
As
far
as
the
learning
curve
is
concerned,
Paz
did
have
a
very
nice
learning
curve.
You
could
get
started
really
really
easily
and
you
could
deploy
widely
and
everything
would
be
great.
That
is,
of
course,
until
you
needed
to
do
something
that
the
pass
couldn't
handle
at
which
point
I
call
it
the
cliff
of
despair
where
suddenly
you're
trying
to
do
this
thing.
It's
not
supported
and
you're
kind
of
looking
over
the
edge
into
the
abyss
into
this
world.
A
Without
that
beautiful
pass
that
you've
been
using,
because
it
can't
do
what
you
need
it
to
do,
and
you
suddenly
have
to
learn
all
these
things
yourself,
kubernetes.
On
the
other
hand,
I
think
it
gets
a
bad
rap,
perhaps
fairly
for
being
a
little
bit
tough
to
get
started,
but
at
the
same
time
you
can
do
so
much
with
it
that
it's
a
very
valuable
skill
to
have,
and
so
I
think,
like
you
know,
particularly
I'm.
Guessing
everyone
in
the
room
here
are
professionals.
A
You
know
if
this
is
your
career,
if
you
want
to
be
a
DevOps
engineer,
then
I
think
learning
the
tool
that
allows
you
to
express
the
most
range
of
deployments
in
handle.
The
most
number
of
situations
is
ultimately
the
most
valuable
and
if
that
takes
an
extra
day
to
learn,
it's
probably
going
to
pay
off.
A
A
So
when
you're
looking
at
tools
and
when
you're
looking
at
things
to
improve
efficiency,
if
you
pick
ones
that
you
know
just
tackle
the
very
easy
problems
and
they're
like
hey,
here's,
an
easy
problem
but
we're
gonna
make
it
even
easier
and
it's
sort
of
like
you
look
at
that,
and
it's
like
hey,
that's
pretty
good,
like
I.
Want
that
to
be
easier,
but
then
are
you
gonna
have
that
cleaver
to
spare?
A
A
But
are
there
some
lessons
we
can
learn
from
passing?
Are
there
some
things
that
we
can
bring
in
so
with
kubernetes,
you're
kind
of
in
control?
You
have
all
of
the
dials.
You
have
all
the
knobs.
You
can
do
everything,
even
if
most
the
time
you
just
want
to
turn
on
autopilot
alright.
So
what
are
the
things
to
strive
for
when,
when
you
look
at
bringing
the
innovative
features
from
pairs
over
to
the
kubernetes
world,
I've
got
a
bit
of
a
list
here.
The
first
one
is
get
push
to
deploy.
I
think
this
is.
A
This
is
kind
of
the
the
basic
building
block.
It's
really
nice
to
be
able
to
just
push
the
code
and
have
systems
take
care
of
that
with
like
a
continuous
integration
pipeline.
Let
me
just
highlight
a
quick
demo
on
getting
this
working.
I
mainly
just
want
to
show
just
how
easy
this
can
be.
There
are
a
whole
bunch
of
tools
that
can
do
this.
A
Some
here
today,
at
couponer,
like
we've
works,
have
one
get
lab
code,
fresh,
they're,
three,
that
I've
tried
I'm
sure
there
are
many
others,
but
let
me
just
do
a
quick
demo
with
Google,
so,
firstly,
I'm
just
going
to
do
the
manual
process
where
I'm
going
to
build
my.
This
is
just
a
very
simple
nodejs,
app
and
I'm
going
to
build
that
locally
and
I'm
going
to
push
that
up.
A
And
here's
a
deployment
manifest
I
prepared
earlier
as
I
said,
I'll
be
showing
a
link
to
all
this
code.
So
if
you
want
to
look
at
what's
in
that
Yammer,
you
can
it's
fairly
fairly
kind
of
stock
standard,
kuva
news
channel,
of
course,
with
the
obligatory
kind
of
craft
at
the
top,
the
container
that
I
just
built
a
readiness
probe
which
is
fairly
important.
So
the
readiness
probe
just
means
that
there's
a
little
health
check,
that's
just
pinging
the
container
to
know
when
it's
actually
up
and
ready
to
serve
traffic.
A
A
A
Alright,
while
it's
going
up,
let's
switch
over
to
container
registry
and
create
a
build
trigger,
so
whenever
I
push
a
change,
is
gonna
trigger
a
CI
build
so
we'll
just
select
that
repai
that
I
just
created
now
I'm
just
gonna
leave
everything
default
here.
So
it's
just
gonna
pick
up
the
doc
file
and
build
an
image
again
pretty
standard
CI
to
make
it
interesting.
Let's
make
a
change
in
the
code,
so
I
want.
Let's
just
say,
hello,
cube,
gone
Copenhagen.
A
A
Okay
and
we're
pushing
it
up
to
the
registry,
and
once
that's
ready,
this
is
the
image
that's
going
to
create.
So
it's
just
a
I'm
just
using
the
SHA
is
that
the
tag
there
and
I
can
deploy
that
image.
Just
using
a
cube,
CTL
set
image,
we're
gonna
see
a
rolling
update
happen.
It's
gonna
take
about
a
minute
and
while
we're
waiting
for
that,
I'm
gonna
I'll
skip
ahead
to
the
next
bit,
and
that
is
this
was
only
going
to
give
us
a
continuous
integration.
A
Obviously,
what
we're
striving
for
is
git
push
to
deploy,
so
we
need
the
CD
part.
So
let
me
just
edit
this
trigger
and
I
think
there's
another
option
here,
which
is
a
cloud
build
yeah
Mel.
So
this
is
a
little
bit
more
advanced
than
the
docker
file.
It
allows
me
to
actually
specify
a
bunch
of
steps
and
one
of
those
steps
can
be
deployment
all
right.
Let's
see
how
this
is
going,
it
still
got
a
couple
of
pods
waiting
to
terminate
and
might
still
be
serving
some
traffic.
A
All
right
there
we
go
someone's
working
now,
let's
get
back
to
this
up,
leveled
build
trigger
that
I
just
switched
over
to
so
in
this
case,
we're
using
this
cloud
bill
tamil,
which
has
a
food
which
has
just
three
simple
steps
in
it.
The
first
step
is
the
build
using
the
exact
same
come
on.
I
just
did
locally.
A
The
next
is
a
push
again
exactly
what
I
showed
locally,
and
the
final
step
is
using
the
cube
CTL
container,
where
we
set
the
environment
variables,
which
has
the
convenience
of
actually
automatically
provisioning,
all
the
credentials
and
needs,
and
then
we're
doing
a
set
image,
which
is
exactly
what
I
ran.
It
ran
on
the
left
here,
all
right,
so
let's
make
a
change
and
push
that
up
and
see
if
it
all
works.
A
So
you
can
see,
we've
built
the
image,
we're
now
pushing
the
image,
and
hopefully
the
final
step
will
be
a
deployment
which
is
here
cube.
Ctl
set
image
with
that
image
I
just
built,
and
we
can
see
that
looks
like
the
containers
already
been
created,
we're
just
waiting
for
them
to
become
ready
and
I'll
take
another
30
seconds
or
so
so,
like
I
said,
I
did
add
a
readiness
check
to
these
containers.
So
it's
just
gonna
wait
until
it's
actually
able
to
receive
traffic,
which
is
a
certainly
good
practice
to
do.
A
A
So
what
other
things
should
we
consider
as
we
bring
the
most
innovative
features
into
communities?
Well,
one
thing
is
that
was
a
very
simplistic
term.
I
just
gave
as
I
mentioned
communities
is
a
declarative
style
infrastructure,
so
that
does
mean
you
have
a
lot
of
configuration
which
is
declaring
the
state
of
your
deployments.
So
typically,
you
may
want
to
take
that
very
simple
pipeline
and
make
it
a
little
bit
more
complex.
A
Using
this
concept,
called
configuration
is
code
where
you
just
commit
in
all
of
the
communities
manifests
into
the
source
control
where
it
can
go
through
the
same
code
review
processes
that
your
actual
application
goes
through,
and
you
get
some
nice
properties
like
rollback,
being
able
to
rollback
a
deployment,
a
good
rollback
beyond
a
rollback,
a
production
deployment,
and
you
might
end
up
with
two
pipelines.
Looking
some
like
this,
the
one
at
the
top
is
for
the
code,
repo,
which
is
just
going
to
build
a
container.
A
The
bottom
one
is
another
pipeline
where
all
it
does
is
look
for
changes
to
the
configuration
which
it
rolls
out
and
then
the
dotted
line
in
between
is
you
know
an
optional
step.
You
can
add,
we
can
just
get
the
after.
It's
built
the
image
you
can
just
like
update
the
configuration
automatically
and
you
can
tailor
that
to
whatever
staging
production
type
setups.
You
want
another
really
innovative
feature
that
I
think
you
probably
will
want
to
bring
in
to
kubernetes.
A
Is
the
concept
of
review
apps
so
assuming
that
you're
doing
a
code
review
style
workflow,
which
is
certainly
highly
recommended?
What
review
apps
do
is
they
can
create
an
ephemeral
instance
of
the
entire
application
with
the
code
that's
under
review?
That
means
that
your
code,
reviewers,
can
not
only
review
the
code,
but
they
can
actually
try
it
and
see
it.
Running.
Live
kubernetes
really
supports
this
concept.
Well,
because
humanities
has
namespaces,
we
can
isolate
various
different
workloads,
so
you
can
actually
have
just
an
ephemeral
namespace
just
for
that
review,
app
running
in
the
same
cluster.
A
A
So
to
solve
that
problem,
we
actually
created
this
program
called
the
certified
kubernetes
program
that
Dan
Kohn
introduced
at
the
last
cube
con
in
the
keynote
the
good
this
will,
if
you're
using
a
certified
kubernetes
vendor,
you
can
have
a
fair
degree
of
confidence
that,
whatever
you
do,
is
going
to
be
portable
and
the
good
news
is
it's
very
easy
to
actually
find
a
certified
cubanía
vendor,
because
it's
basically
all
the
vendors.
So
there
you
go.
A
Let's
just
make
sure
that
that
stays
true.
The
next
thing,
of
course,
if
you're
come
in
from
the
PA's
world,
I
think
you
say
you
want
to
automate
everything.
You
know
it
wasn't
a
great
not
having
to
worry
about
infrastructure.
Well,
you'll
want
to
come
to
communities
and
have
to
worry
about
infrastructure,
I,
don't
think,
certainly
speaking
for
Google
container
kubernetes
engine,
we
offer
automation
for
just
about
everything.
A
So
as
we
do,
this
transition
I
think
there's
also
a
few
things
to
consider
carefully.
One
is
poorly
supported
dependencies,
so
I
mentioned
at
the
beginning.
One
of
the
great
things
about
kubernetes
is,
though,
there's
this
wonderful
community
of
open
source
tools
that
you
can
use.
Of
course,
you
definitely
wanna
make
sure
that
those
are
actually
well
supported,
open,
source
tools.
We
had
this
model
at
my
mi
startup
back
when
I
was
working
there
kind
of
six
years
ago
that
if
you
clone
it,
you
own
it
now.
A
It
does
this
by
analyzing
your
code
and
kind
of
working
out
what
dependencies
that
thinks
you
need
and
building
up
an
artifact
for
you
I
think
in
the
kubernetes.
Well,
this
is
a
bit
of
an
anti-pattern,
because
you
kind
of
lose
a
lot
of
the
benefits
of
containers
in
the
first
place.
I
personally
found
like
in
my
journey
to
kubernetes.
There
were
certainly
some
hard
things
that
I
had
to
learn,
but
one
of
the
simplest
things
I
found
was
just
container
racing.
My
app
you
just
go
online.
A
You
find
a
good
template,
you
copy
it,
you
tweak
it
and
that's
it.
You
also
get
a
lot
of
benefit
from
that
step
too,
because
now
that
you've,
actually
in
Tanner
eyes
your
app
you
can
test
it
locally.
Should
you
wish,
just
straight
from
the
docker
container,
so
it'll
be
something
that
I'd
probably
avoid.
Personally,
the
build
pack
model
also
meant
that
you
would
break
on
deploy,
so
you
you
could
actually
have
everything
working
nicely
locally.
A
You
solve
that
and
you
solve
that
earlier
in
the
process,
which
is
nice
pricing
models,
I
think
another
thing
to
just
consider
carefully
with
kubernetes,
so
whether
you
go
for
like
a
node-based
one
or
a
container
based
one
I
personally,
like
the
benefit
of
kubernetes,
so
you
can
bin
pack
a
whole
bunch
of
services
and
workloads
onto
a
shared
pool
of
resources
that
typically
only
works
with
a
no
base
pricing.
Obviously
you
know
there
are
a
lot
of
considerations
here,
but
just
something
to
consider
right.
A
So
now
I'd
like
to
talk
about
rapid
application
development
on
kubernetes,
so
so
far
the
talk
is
focused
on
how
to
bring
some
of
those
great
features
of
paths
into
communities.
Well,
now
there
were
in
kubernetes
what
are
some
really
great
things
we
can
do
so.
The
containerization
part
sould
solved
that
break
on
deploy
that
bill
packs
had,
but
you
still
probably
do
want
to
test
the
actual
complete
deployment
of
kubernetes,
including
the
manifest
file.
A
Also,
if
you've
adopted
the
microservices
style
of
communities,
fear
for
your
application,
the
micro-services
architecture
you'll
probably
have
a
lot
of
appendices
that
you
may
need
to
bring
up.
As
you're
testing
locally,
so,
if
I
think
there
was
a
good
tool
that
could
solve
both
these
well,
as
you
might
have
seen
in
Aparna's
demo
this
morning
in
the
keynote
google
recently
opened
sourced
a
very
neat
tool
called
scaffold
which
enables
rapid
application
and
deployment
rapid
application
iteration
with
kubernetes.
A
It's
very
simple
to
use
so
I'm
gonna
do
a
little
bit
of
a
longer
demo
than
what
she
did
this
morning
for
you.
You
just
have
to
drop
in
this
one
configuration
into
your
project
and
there's
really
only
three
things
that
matter
here:
I'm
specifying
the
the
image
name
that
I
want
it
to
build,
I'm
directing
it
at
the
manifest
files
that
I
have
in
my
project
and
I'm
just
specifying
what
profile
I
want
to
use.
A
A
So
we
have
containers
just
created
six
seconds
ago
and
be
aware
that
the
only
thing
I
did
was
hit,
save
in
my
IDE.
Just
then
I
didn't
do
anything
else.
I
just
hit.
Save
scaffold
is
watching
that
code
repository
and
ready
to
make
the
changes.
The
other
thing
it's
doing
is
it's
actually
watching
for
configuration
changes.
So
if
I
actually
edit
the
kubernetes
manifest
and
say
change
the
number
of
deployments
from
three
to
five
you'll
see
that
change
get
rolled
out
as
well.
A
A
A
If
we
can
reduce
the
deployment
time
down
to
one
minute,
then
if
you
have
like
a
fairly
complex
application,
we
say,
like
you,
know,
ten
different
services
or
if
you
just
want
to
run,
you
know
fairly
performant
ly
as
if
it
was
in
production,
kind
of
quote
more
close
to
your
production
environment.
Then
it's
just
nice
to
just
use
the
remote
Cuban
any
service.
Of
course
you
can
use
mini
cube
as
well.
A
I
personally
find
at
least
on
Mac
Mini
Cube
is
all
bit
slow
because
it's
having
to
spin
up
a
Linux
VM
to
run
everything
okay.
So
what
if
I
make
an
error
in
my
code?
Let's
this
is
nodes,
so
any
code
errors
here
are
just
going
to
be
runtime
lines
rather
than
build
time.
I'm
just
going
to
put
a
little
typo
in
this
method,
call
and
we'll
see
what
happens
so.
A
As
before,
scaffold
is
watching
for
the
changes
and
it's
rebuilt,
the
image,
no
errors,
because
it's
it's
node
and
one
of
the
nice
things
about
scaffold
is
that
it's
automatically
going
to
be
connecting
to
those
pods
that
are
running
and
piping.
The
output
right
in
the
console
here
and
so
I
can
immediately
see.
Oh
there's
an
error
coming
out
of
those
containers.
A
Clearly
headed,
it
is
not
a
function.
So
let
me
fix
that
and
it's
gonna
redeploy
it
and
I
really
like
that
as
well,
because
so
it
solves
kind
of
one
of
the
annoying
things
with
kubernetes.
Where
you
know
you
build
you
sort
of
deploy
it
you're
watching
the
deployment
everything
rolls
out.
It
looks
great
and
then
you're
sort
of
like
now
one.
Why
isn't
it
working?
Then?
You
have
to
like
start
logging,
everything
and
trying
to
work
out
what's
going
wrong.
A
Cool,
so
that
is
rapid
application
development
with
kubernetes,
and
that
completes
my
story
about
PES
de
communities,
combining
the
most
innovative
features
of
pears,
reindeer
cookies.
I
think
we
have
some
time
for
some
questions.
So
please
ask
away.
Let
me
see
if
anyone's
asked
anything
on
Twitter
as
well.
A
B
A
Great
question,
so
the
question
is
I
mentioned
earlier,
that
be
wary
of
things
that
make
the
simple
easier:
doesn't
scaffold,
make
the
simple
easier
and,
and
what
about
what
about
pitfalls?
Like
you
know,
making
sure
the
TLS
things
are
working
and
everything
so
I
think
scaffold
solves
one
particular
problem,
which
is
the
rapid
iteration
at
the
development
stage?
What
it
doesn't
do
is
it
doesn't
replace
a
good
CI
CD
pipeline
with
like
review
apps
and
staging
environments
and
production
environments.
A
A
I
think
scaffold
is
a
little
bit
better
than
that,
because,
because
you
are
using
the
same,
kubernetes
manifests
that
you
deploy
in
a
production,
you're,
probably
getting
closer,
so
I
think
anything
that
gets
you
closer
to
production
is
better
yeah,
I,
guess
I,
guess
I
see
it
just
as
like
one
complementary
tool
in
the
in
the
toolbox
and
not
and
not
kind
of
replacing
like
a
good
CI
CD
pipeline.
Thanks
for
the
question,
that's
a
really
good
one!
Another
one.
A
Are
you
still
using
the
container
registry
when
you're
using
scaffold?
The
good
news
about
scaffold?
Is
that
it's
very
pluggable,
so
you
can.
The
demo
I
showed
was
using
a
Google
container
builder.
So
the
same
the
same
tool
that
I
showed
in
the
earlier
demo
was
being
used
by
scaffold
and
that's
configured
here
in
the
in
the
profile
section
so
that
it's
using
Google
Cloud
build
and
I've.
Given
it
the
project
ID,
you
can't
actually
just
run
it
locally,
with
mini
cube
as
well.
So
you
know
you
can
attach
a
different
container
registry.
A
A
A
Very
good
question,
so
the
question
is
in
my
example:
here
I
was
making
a
very
kind
of
simple
and
contain
change.
What
would
happen
if
you,
if
you're,
making
lots
of
separate
changes?
Well,
let's
give
it
a
try.
So
I'm,
gonna,
I'm
gonna,
make
a
change
here
now.
I
won't
save
it,
but
I'll
save
that
and
then
I'll
very
quickly.
A
A
See
I
think
I
think
it
is
actually
doing
what
I
expected.
It's
interrupting
that
that
other
building
is
just
starting
it
again.
So
I
guess
you
might
be
burning
some
cycles,
they're
just
building
stuff,
you
don't
need,
but
the
good
news
is
like
if
you're
saying
it's
going
to
take
two
minutes
to
build
that
at
least
be
two
minutes
since
your
last
change,
so
I
hope
that
answers
the
question.
A
A
A
It
is
I
was
actually
surprised
how
easy
it
was
to
use
like
it
was
literally
just
I
ran
that
command
and
then
I
created
this
file,
I
adapted
it
from
the
the
template.
I
changed
the
project
name
there
and
there
and
pointed
at
my
kubernetes
manifest.
So
this
line
here
is
basically
just
saying:
Mike
who
buries
manifests,
follow
the
convention
ka
T's
staff
that
could
also
be
in
a
directory.
That
was
basically
it
pretty
pretty
easy.
Actually.
C
A
Don't
want
to
have
to
get
back
to
on
so
the
question
was:
can
I,
listen
to
hooks
from
artifactory
or
other
artifact
repositories,
I
feel
like?
Maybe
it
should
be
able
to
if
it
doesn't
today,
but
I'll.
Take
that
as
a
follow-up
and
I'll
get
have
to
get
back
to
you
all
right.
One
last
question:
do
we
have
any
great
thanks?
Everyone
for
joining
me
today
enjoy
the
rest
of
cube
con.