►
From YouTube: Jenkins X: Easy CI/CD for Kubernetes - James Strachan, CloudBees (Intermediate Skill Level)
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).
Jenkins X: Easy CI/CD for Kubernetes - James Strachan, CloudBees (Intermediate Skill Level)
This talk will introduce you to a new open source project, Jenkins X, which is an open source CI / CD platform for Kubernetes based on Jenkins. After a short introduction James will spent most of the talk demonstrating how to develop applications with CI / CD on Kubernetes with Jenkins X: easily setup your own CI / CD system on your cloud of choice using standard tools: kubernetes, draft, helm, jenkins * quickly create new microservices or import existing projects with automated CI / CD * use Pull Requests to trigger CI, Preview Environments, human approval then a full CD release * use automated provisioning to Preview, Testing, Staging & Production environments via helm charts and GitOps After this talk you should be able to develop cloud native apps at full speed with automated CI / CD in any language on any kubernetes cluster! Lest go faster!
About James
I work on CI + CD for Kubernetes with Jenkins for CloudBees. I'm the lead architect of Jenkins X. I also created the Groovy programming language, Apache Camel & was a founder of fabric8 & ActiveMQ. I've spoken at many conferences over the years (DevOxx, QCon, JavaOne, JFokus, ...) but never KubeCon!
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
Hello,
everybody
welcome
to
coop
con
I
hope
you
still
awake.
It's
been
a
busy
day,
I'm
James
truck
and
I'm
gonna
talk
to
you
about
Jenkins
X
today,
so
let
let's
get
started
now.
Kuban
86
is
awesome
like
we
all
know
Cuban,
it
is
awesome.
It's
amazing
technology.
It's
got
an
incredible
community
and
it's
just
really
really
useful
right.
It's
awesome.
One
of
the
big
challenges
that
with
Cuban
it
is,
is
how
do
you
use
it
right?
How
do
you
actually
use
it
to
do
development
and
develop
software?
A
Well,
we're
increasingly
all
trying
to
become
high-performing
teams
and
to
go
fast,
so
we
all
want
to
do
micro
services.
We
all
will
have
spin
up
projects
all
the
time
and
experiment.
We
want
to
go
fast.
You
want
CIN
CD.
We
want
to
continuously
deliver
value
this.
The
challenge,
though,
is
how
to
figure
out
how
to
take
cuban
at
ease
and
all
of
this
different
stuff
in
the
cubans
ecosystem,
put
it
all
together
and
make
a
really
awesome,
cncd
ecosystem.
A
Now,
if
you're
a
team
right
now
trying
to
go
fast,
you've
got
all
these
kind
of
things.
To
figure
out.
You
need
to
figure
out
how
to
set
up
cuban
eighties
and
create
your
own
cluster.
You
need
to
figure
out
how
to
set
up
multiple
environments.
You
need
to
figure
out
how
to
set
up
docker
files
for
all
of
your
apps.
Then
you
need
to
figure
out.
Do
I
go
Yammer
or
do
I
go
helm
then
you
need
to
figure
out
what
your
pipelines
look
like.
A
The
weave
works.
Folks
came
up
with
agate
ops
name,
which
I
think
is
awesome,
I.
Think
most
of
us
kind
of
do
this
now
right.
We
put
all
of
our
operational
configuration
in
get
so
everything's
back
to.
If
ever
you
lose
your
cluster,
you
can
just
recreate
it
and
all
the
configurations
in
there.
If
anybody
messes
anything
up,
you
can
just
do
a
git
revert
right,
so
using
git
tops
is
awesome
and
then
finally,
we
need
to
actually
deliver
some
business
value.
A
A
So
this
is
where
Jackie's
ex
comes
in,
so
Jackie's
ex
is
really
trying
to
help
you
do
all
of
that
stuff
right
now.
What
we
kind
of
want
to
do
is
turn
all
of
this
CI
and
CD
and
stuff
into
just
an
appliance
that
works
so
use
a
developer.
Can
just
write
code
and
stuff
just
happens
right,
so
you
don't
have
to
mess
around
with
docker
files.
A
You
don't
have
to
tweak
helm
shirts,
you
don't
have
to
write
Jenkins
files,
you
just
create
apps
and
be
happy,
and
all
of
this
stuff,
ci
and
CD,
just
kind
of
happens
for
you
right.
So
that's
the
idea.
So
what
does
Jenkins
X?
Do
it
automates
the
installation
and
configuration
of
a
whole
bunch
of
different
tools?
A
So
there's
there's
obviously
kubernetes,
then
there's
jenkins
as
well,
but
there's
other
tools
like
scaffold:
how
a
bunch
of
stuff
monocular
there's
a
whole
range
of
different
bits
of
software,
that
we
need
to
really
do
CIN,
CD,
world
and
kubernetes.
So
we
automatically
install
and
configure
all
this
stuff,
so
you
don't
have
to
mess
around
trying
to
get
Jenkins
to
talk
to
Nexus
or
any
of
that
kind
of
crappy.
It
does
it
all
for
you,
so
it
installs
your
stuff.
It
also
gives
each
it
automates
the
generation
of
all
of
your
pipelines.
A
So
whenever
you
want
to
create
an
app
or
import
an
app,
it
just
sets
up
the
CIA
city
pipelines
for
you.
It
adds
a
docker
file.
If
there
isn't
a
docker
file
already,
it
adds
a
Jenkins
file.
If
you
haven't
written
the
Jenkins
file,
it
adds
a
helm
sure
if
you
have
a
green
help,
shell,
so
it
automates
the
setup
of
your
applications
and
then
it
basically
automates
the
promotion
through
testing
staging
and
production.
Ok
and
then
there's
lots
and
lots
of
feedback
which
you'll
see
in
a
moment.
Feedback
is
crucial
to
go
fast.
Really.
A
A
So
that's
what
Jenkins
X
is
trying
to
do
for
you.
So
how
do
you
get
started
on
this
Jenkins
X
thing?
What
you
need
to
do
to
get
started?
So
please
don't
try
this
right
now,
because
I'm
gonna
hopefully
use
the
Wi-Fi
soon
to
do
a
demo.
But
after
my
talk
you
can
type
this
in
to
download
Jenkins
X
binary,
so
there's
Jenkins
X
as
a
binary
called
G
X,
which
is
the
command-line
tool
you
use
for
interacting
with
Jenkins
X
right.
A
So
you
need
to
get
this
binary,
not
right
now
like
in
about
half
an
hour
download
the
binary
on
to
your
laptop.
If
you
use
a
Mac
just
use
Bru,
if
you
use
Linux
copy
and
paste
that
or
you
can
go
to
the
website
and
download
the
binary
and
pocket
in
your
path,
so
you
need
the
Jake
is
X
binary,
then
your
neck.
Then
the
next
thing
you
need
is
a
kubernetes
cluster
with
jenkins
x,
installed
on
it.
Now
we
support
Amazon,
Google
and
Microsoft's
clouds,
so
we
have
a
command
J
X
create
cluster.
A
You
then
type
the
kind
of
cloud
you
wish
to
use
so
AWS
for
Amazon
air
KS
for
a
zero-g
ke
for
Google
using
Google's
content
engines.
We've
got
off
a
few
other
options.
If
you
really
really
want
you
can
use
mini
Cube
on
your
laptop,
but
it's
kind
of
not
real,
so
we'd.
Rather,
you
use
a
real
cloud.
You
don't
shut
your
laptop
down
and
your
entire
CI
CD
infrastructure
kind
of
stops
right.
You
use
the
cloud
for
good.
A
So
these
any
one
of
these
three
commands
spins
of
a
brand-new
cluster
of
kubernetes
and
puts
Jenkins
X
on
top
of
it
right.
If
you
already
have
a
cluster
to
hand
that
someone's
giving
you
or
something
or
configured
for
you,
maybe
you're
you're,
you
want
all
of
this
on-premise,
so
you
you've
used
cube
spray
or
cubed
a.m.
or
something
like
that
on
premise,
just
use
Jake's
install
and
that
will
use
whatever
kubernetes
cluster
you're
already
Tokita.
A
So
if
you
can
use
cube,
cuddle
cube
CTL
to
talk
to
a
cluster
jjx
install
will
just
work
on
that
cluster.
We
do
prefer
our
back
to
be
enabled
and
we
do
want
an
ingress.
So
we
can
talk
into
the
cluster
to
do
things,
but
a
path
on
that
it
should
work
with
most
kind
of
modernish
cuban
Nettie's
clusters.
A
Okay,
so
especially
one
command
to
install,
and
that
gives
you
everything
you
need
in
the
box,
which
is
not
as
simple
here's
a
little
demo
how
to
play
it
really
quickly,
a
little
demo
of
using
installing
a
cluster.
So
we
type
JX
create
cluster.
In
this
case,
gke
a
then
ask
you
a
couple
of
things
like
how
many
nodes
do
you
want
wish
to
use?
How
big
a
node
that
you
want
to
use
in
your
node
pool,
then
it
basically
spins
over
cuban
its
cluster.
This
video
is
slightly
sped
up
right.
A
It
takes
two
to
three
minutes,
usually
Jiki.
It
can
take
a
little
bit
longer
on
some
of
the
other
clouds,
but
Jiki
is
normally
quite
quick.
Then
it
is
source,
jenkees
X,
then.
The
last
thing
is,
though,
so
you
can
just
see
this
last
bit.
It
sets
up
to
git
repositories.
I'll
come
back
to
those
git
repositories
in
a
minute,
but
those
are
your
environments.
Those
are
the
git
repositories
for
doing
get
ops.
So
that's
your
staging
environment
in
your
prediction,
your
own
well,
we'll
come
back
to
those
in
a
minute.
A
So
it's
basically
pretty
quick.
You
type
one
come
out
in
a
half
an
hour
type
that
one
command
and
you
can
have
your
own
kubernetes
cluster
with
Jenkins
X,
on
top
of
it,
ok,
which
is
cool
so
now.
What
does
that
give
me?
So
each
team
gets
their
own
development,
environment
or
home
environment
where
we
install
a
bunch
of
tools,
so
we
install
things
like
Jenkins
and
Nexus
and
monocular
and
various
other
bits
and
pieces.
So
you
get
your
own
namespace
with
your
own
sets
of
tools
in
there,
so
you
run
Jenkins
and
stuff.
A
We
give
you
a
Jenkins
master
by
default
and
an
elastic
pool
of
Jenkins
pods
build
pods,
which
is
where
the
pipelines
run.
So
there's
no
more
waiting
for
this
huge
build
pipeline.
To
kind
of
you
know
own
queue.
Also
each
team
gets
their
own
Jenkins
master.
So
you
just
see
your
jobs
right.
You
don't
look
at
Jenkins
to
have
50
gazillion
builds
for
everybody
in
your
organization.
You
get
your
own
Jenkins
master
with
your
own
builds
and
inside
it,
and
you
get
your
own
elastic
slave
pool
right.
That's
all
right
always
available.
A
Each
team
also
gets
their
own
staging
environment
and
production
environment,
so
lots
of
different
teams
can
all
be
working
in
parallel
and
there's
no
kind
of
conflict
with
each
other
right.
Each
team
can
release
anything
to
their
staging
environment
or
particularly
run
whenever
they
wish.
There's
no,
like
big
long
meetings
to
agree
when
you
can
go
to
production.
Each
team
can
just
go
fast
if
they
wish
right.
So
there
we
go.
So
that's
that's
what
Jenkins
X
gives
you
now,
let's
use
it
so
now,
I'm
gonna,
try
use
conference
Wi-Fi
on
Google
cloud
and
github.
A
A
Okay,
so
I'm
praying
to
the
demo
gods
as
a
as
a
type.
Let's
see
how
well
this
girl's
first
yeah,
that's
a
good
start.
Okay,
the
internet
suits
you
working.
So
these
are
the
environments.
I
have
right
now
right,
so
Jay
X
is
just
a
command
line
that
let
gives
you,
those
are
lots
of
commands.
So
this
is
all
the
environments.
I
have
so
I
have
a
my
development
environment
have
a
personal
edit
environment
where
I
can
run
my
own
stuff.
I
have
a
staging
environment
than
that
got
a
production
environment.
A
What
I'm
gonna
do
is
I'm
going
to
create
an
app
for
you.
We're
gonna
see
it
go
from
testing
to
staging
and
then
eventually
production.
So
with
the
type
JX
creates
QuickStart
and
I'm
gonna,
say
yeah
use
my
username
and
it's
going
to
give
me
a
bunch
of
different
QuickStart
I'm
gonna
pick
this.
This
is
cube.
Khan
and
kubernetes
go
all
the
way
down.
So
I'm
gonna
stick
to
go
to
there
from
my
demos.
A
We
do
support,
you
know
spring
and
maven
and
Gradle
and
lots
of
other
programming
languages,
but
with
a
stick
to
go
for
this
demo
and
let's
call
the
app
girl
cube
con.
That's
quite
a
nice,
then
go
to
Cooper
cool,
so
it's
gonna
create
a
bunch
of
source
code.
On
my
laptop
now
he's
gonna
ask
me:
do
I
want
to
initialize
a
git
repository
for
this
code?
Yes,
please
because
it's
not
engaged
yet
so
those
are
the
files
have
is
created.
So
there's
not
too
much
there.
A
A
little
girl
file
in
a
couple
of
readme
Xin
a
couple
of
scripts.
What's
the
commit
message
that
looks
fine
to
me
now,
it's
gonna
run
the
build
pack
which
is
going
to
look
at
this
project
figure
out
what
it
is.
It's
go,
it
needs
a
docker
file.
It
needs
a
helper,
it
needs
a
pipeline,
so
it's
gonna
add
a
bunch
more
files
in
there.
So
it's
added
you
can
see
it.
Sadly,
the
docker
file
is
said
that
the
jenkees
file,
it's
added,
some
help
shirts
and
right
at
the
bottom.
That's
a
scaffold.
A
Llamó
scaffold
is
a
tool
from
Google
that
builds
docker
images
and
redeploys
them.
Helm
is
a
tool
for
Microsoft
that
does
packaging.
Is
a
package
manager
for
kubernetes,
so
using
helm
for
packaging
and
we're
using
scaffold
for
building
right
and
then
it's
gonna
say:
do
I
want
to
use
my
username
to
important
to
github
yeah.
That
sounds
good,
which
organization
I'll
keep
it
in
my
personal
one,
that
repository
looks
fine
to
me.
So
now
it's
going
to
create
a
git
repository,
so
it's
generating
some
source
code.
A
It
supplied
the
build
pack
to
add
the
missing
files.
Now
it's
important
listen
to
get.
Oh,
it's
important
to
get
brilliant.
So
now,
I've
got
a
git
repository
just
to
show
you
that
I'm
not
cheating.
Let
me
look
at
that
on
github.com
yeah.
He
get
himself,
okay,
brilliant,
so
GitHub's
working.
That's
a
good
start
so
Gibbs
this
is
the
repository
we
just
created
and,
as
you
can
see,
there's
a
that's
a
truly
amazing
piece
of
software
right
there.
A
The
prints
are
message
to
the
screen,
so
that's
a
micro
service,
so
we
starting
small
and
simple
and
then
we're
going
to
improve
right.
So
it's
kind
of
crappy
now
and
it
could
only
get
better,
there's
a
little
command
here.
You
can
type
in
and
copy
and
paste
JX
get
activity.
And
what
this
does
is
this
tails
to
the
log
what's
happening
in
this
pipeline
under
the
covers?
A
So
let
me
just
explain
what
just
happened:
I
typed
one
command
JX
create
quick
stir
that
create
a
brand
new
project
imported
it
into
github
registered
web
hooks
on
github.
So
that
way,
therefore,
a
pull
request
or
emerge
the
master
happens.
It
triggers
a
Jake,
its
pipeline.
It's
set
up
at
Jenkins
pipeline
with
the
CIN
CD
and
then
because
we
merged
to
master
our
push
to
master
is
now
triggered
a
pipeline
which
is
now
tricking
along
here.
So
now
what
that's
gonna
do.
Is
it's
gonna
release
the
first
version
of
this
incredible
QuickStart
right?
A
So
the
first
version
has
been
released
right
now,
so
we
can
see
it's
chugging
along
if
actus
released
something
just
about.
So
it's
building
a
release
that
if
I
look
at
github
by
the
way
and
I
go
back
here
and
I
click
on
the
cube
current
project,
you
can
see
on
the
release
page,
we
have
a
release,
so
it's
create
a
release
in
github.
It's
tagged
all
the
source
code
with
the
first
version
number.
It
starts
at
zero
zero
wall
and
then
goes
up
incrementally.
If
ever
you
want,
you
can
create
gate
tag.
A
If
you
want
to
go
to
to
was
on
the
B
one
go
to
one
zero,
you
just
could
do
a
git
tag,
it's
so
it's
now
tagged
all
the
source
code
with
that
version.
So
we
know
it
version
zero,
zero,
one,
what
it
is
and
how
he
differs
in
source
code
from
zero.
Zero
to
the
pipeline
is
then
under
the
covers.
The
pipeline
is
now
built
a
docker
image
tags
that
he
made
with
zero
zero
one
push
that
docker
image
into
the
docker
registry.
It's
then
packaged
up
a
helmet
installed.
A
A
What
this
pull
request
does
you
can
see
by
the
way
the
pull
request
has
got
a
CI
build
running
at
the
same
time
as
well
I've
generated
a
pull
request
if
I
look
at
this
pull
request,
don't
worry
too
much
about
the
detail,
but
this
pull
request
is
adding
three
lines
to
a
Yama
file:
those
three
lines,
because
we've
never
deployed
this
application
in
this
environment
before
so.
We're
adding
three
lines
to
say:
add
this
app
and
add:
zero.
A
Zero
1
of
this
app-
and
this
is
where
this
is
the
repository
that
this
app
lives
in
so
we're
doing
a
pull
request
to
deploy
the
app
into
that
environment.
Write
that
pull
request.
I
think
it's
closed
already.
Has
it
yeah
it's
closed
already,
so
the
pull
request
is
merged.
So
what
happened
under
the
covers
is
that
triggered
that
pull
request
trigger
the
CI
job
on
the
environment,
to
verify
that
the
Yama
was
fine
it
could.
It
could
find
the
chart
in
the
chat
repository
the
gamma
wallet
goods
we
verified,
the
pull
request
was
good.
A
Then
it
merges.
Then
the
merge
triggers
a
CI
job.
That
then
applies
the
latest
master
branch
into
staging.
This
is
all
implementation,
details
of
them
explaining
right
now,
but
basically
we're
now
just
about
ready
to
deploy
it
into
staging.
So
what
this
means
now
is
every
time
we
do
a
release
of
any
app,
it's
a
pull
requesting
it.
So
we
can
see
who
changed
what
when
and
why
and
how,
and
if
ever
we
want
to
revert
a
version
we
can
just
revert.
The
git
commit
right,
it's
nice
and
simple.
A
If
you
ever
want
to
change
anything
else
in
production
like
add
prometheus
or
add
some
alerting
thing
or
management
software,
you
can
just
do
a
pull
request
on
the
same
git
repository
right.
If
you
want
to
add
some
custom
configs
on
resources
or
config
maps
or
secrets
or
whatever
it
is,
you
can
do
that
all
through
this
git
repository.
So
all
of
your
operations
and
management
of
each
environment
can
be
in
git
and
use
CI
CD
for
your
environments,
which
is
nice
and
awesome
that
demo
even
worked
like
I,
believe
it.
A
So
we've
now
got
a
live
running
app
in
staging
which,
if
I
click
on
that
it
should
work.
Yes,
oh
hello,
hello,
Jenkins,
that's
brilliant!
So
we've
one
command,
JX
create
quick
start.
We've
set
up
a
CI
NCD
pipeline,
it's
released
to
the
staging
environment
already,
and
that
was
pretty
simple
right.
We
haven't
had
to
look
at
any
files.
We
didn't
have
to
know
anything
about.
Docker,
we
didn't
know
need
to
know
anything
about
helm
or
helm.
Yama,
lor,
cuba,
Nettie's
resources
or
even
what
the
Jenkins
file
is
and
how
it
looks.
A
So
you
can
kind
of
squint
and
see
this
is
er.
It's
a
bit
like
a
serverless
platform.
Now
we
just
chuck
code
in
and
it
runs,
and
we
don't
need
to
know
that
there's
cupola
T's
there
and
there's
those
clusters
and
there's
resources
and
see.
Are
these
and
all
the
other
stuff
now
I'm
a
huge
cuban
eighties
fan,
and
that
would
love
you
all
to
learn
and
use
cuban
eighties
and
learn
at
all
of
its
awesome
power
and
beauty.
But
you
don't
have
to
do
it
yet
right.
A
You
can
just
get
started,
build
some
apps
use
cuban
eighties
as
a
platform
for
building
your
apps
and
over
time,
learn
more
about
save
docker
files
or
jenkins
files
or
helm.
Okay,
so
we've
got
an
app
running.
Let's,
let's
change
some
code.
So
let's
show
you,
we've
shown
you
how
you
do
push
the
master.
Let
me
show
you
how
a
pull
request
works.
So,
let's
see
the
into
the
source
code
on
my
filesystem,
which
is
gold,
cue,
calm,
yeah
there
we
go
and
let
me
open
an
editor
vs
code.
A
So
here's
the
really
awesome
sauce
curve
that
we've
got
in
our
application.
That
just
prints
something
on
the
screen.
What
I'm
gonna
do
is
I'm
gonna,
create
a
branch,
get
branch,
cheese,
I'm
gonna
check
out
the
branch
see
if
I
can
type
I'm
having
a
reasonable
type
in
there.
This
is
amazing,
okay
and
then,
let's
add
more
awesome.
So
let's
say
Jenkins
X,
awesome.
Okay,
so
we've
made
a
change.
If
I
do
a
get
status,
you
can
see
I've
made
the
change
so
I'm
gonna
do
a
git
commit
or
a
a
M
I've
got
I.
A
Never
normally
do
this
by
hand
got
these
aliases
but
I'm
trying
to
keep
it
real
by
tapping
the
real
command.
So
you
know
what
I'm
doing
I
did
awesome.
So,
there's,
okay!
Oh
there
we
go
I'll.
Do
a
git
push
now
if
I
go
back
to
mine,
git
repository
here,
we
go
for
this
one.
So
here's
the
git
repo,
because
we
just
pushed
the
new
branch
github
says:
oh,
would
you
want
to
do
a
full
request?
So,
oh
god
yeah?
Let's
do
a
poor
request,
so
I'll
create
a
pull
request.
A
So
we've
created
pull
request
because
we
want
to
add
some
all
awesome
right.
So
we've
edited
the
code
doesn't
get
commit
pushed
it,
create
a
pull
request
notice
in
the
background
this
pipeline
started.
So
we've
started
the
new
pipeline
because
we've
submitted
a
pull
request,
so
the
CI
CD
pipelines,
don't
just
do
releases
when
you
push
the
master,
they
also
deal
with
pull
requests
that
when
you
make
a
pull
request,
we
have
another
pipeline
that
runs
that
validates.
Is
the
code
change
valid?
Does
it
compile
the
you
test
pass?
A
Can
it
still
run
in
a
docker
container?
Does
the
yamo
for
the
hell
chat,
still
work
and
all
of
those
other
kind
of
things,
so
we're
running
a
pipeline?
Now
on
the
pull
request
to
validate
it's
working?
If
I
look
at
the
pull
request,
we'll
see
you
see
the
port,
you
can
see
from
github
that
the
pipeline's
running
the
canoes
integration
pipelines
running
in
a
few
moments
that
should
hopefully
finish
so
that's
kind
of
cool.
We
get
pull
requests
to
the
CI,
validating
pull
requests,
but
also
we
get
the
release
site.
A
A
We
do
something
called
preview
environments
now,
if
you're
working
on
something
like
a
web,
console
a
web
app
of
some
kind,
and
you
do
a
pull
request
that
changes
the
layout
of
some
HTML
looking
at
the
git
diff
to
approve
a
pull
request,
it's
kind
of
hard
to
know
what
does
the
Apple
look
like
like
I'm
looking
at
this
diff,
and
it
looks
good
to
me,
but
once
it
really
looked
like
in
the
browser,
do
I
like
that
change?
What
we
do
is
we
generate
a
preview
environment
so
that
every
pull
request.
A
You
cannot
tell
that
this,
but
every
pull
request
by
default
is
built
and
deployed
in
a
separate
environment
that
you
can
then
review
the
changes
visually
or
programmatically
or
operationally
before
you
approve
that
change
now
to
go
fast,
we
want
to
keep
master
clean,
so
we
don't
want
to
just
merge
willy-nilly
stuff.
That
goes
bad,
so
we
kind
of
want
to
push
more
human
approval
to
the
pull
request
where
we
can
validate
and
check
through
the
changeless
good
before
we
approve
it
and
notice.
Oh,
it's
gone
green
thank
office.
A
Awesome
he's
gone,
green,
also
notice,
DC
of
a
little
comment.
It
says:
oh,
the
pull
request
was
built
and
it's
available
in
this
preview
environment
here
so
I
click
here
and
here's
the
app
running
in
a
preview
environment
now
so
we've
spun
up
a
separate
environment
just
for
that
pull
request,
we've
built
and
deployed
that
code,
even
though
we've
not
merged
it.
Yet
so
we've
built
the
pull
request
version
of
the
code,
deploy
that
into
a
separate
environment
and
then
link
to
it
on
the
console.
A
A
If
I
click
back
to
this
screen
again
you'll
see
and
now
another
pipeline
is
going
to
kick
off
because
we've
merged
a
master
Lau
so
now
we've
most
merged
that
change
to
master
we've
committed
to
going
forward
without
change
with
most
into
masters,
and
now
mass
is
going
to
release
version,
zero,
zero,
two
yeah.
So
that's
CI
and
CD.
That's
pull
requests
and
releasing
all
the
automated
you
didn't
have
to
write
a
single
page
of
Jenkins
file.
You
didn't
have
to
touch
a
docker
file.
A
It's
all
just
done
for
you
right,
which
is
pretty
cool
so
that
CI
CD
there's
a
bunch
of
different
commands
to
create
new
projects.
If
you
use
spring
boot,
for
example,
there's
a
JX
create
spring
that
are
automate
all
the
spring
initializer
stuff,
the
less
you
spin
a
brand
new
micro
services
with
spring,
which
is
really
really
slick.
A
A
Now,
let's
do
something
a
little
bit
different
I've
just
about
got
time:
let's
do
some
development,
so
let's
do
some
stuff
before
we
do
a
git
commit
write,
less
less
hack
some
code
and
develop
before
we
commit
so
I'm
gonna
run
a
command
called
JX,
create
dev
pod
I'll.
Leave
that
running
in
the
background.
By
the
way,
so
we
can
see
zero
zero.
Two
should
go
alive
fairly
soon.
A
Jake's
create
dev
pod,
and
this
is
going
to
create
a
developer
pod.
Now
the
pipelines
in
Jenkins
X
use
something
called
build,
pods
which
are
a
way
of
defining
what
docker
containers
we
wish
to
use
for
all
of
your
tools.
So
when
we're
doing
cncd,
we
need
to
say
use,
go
or
maven
or
griddle
or
whatever
it
is
to
build
your
app
and
package.
It
open
use
tools
like
helm
to
package
up
a
helm.
They
use
scaffold
to
make
docker
images
and
so
forth.
A
So
we
have
a
whole
bunch
of
tools
which
are
used
to
do
CI
and
CD.
We
have
an
idea
called
a
death
pod,
which
is
you
reuse,
the
exact
same,
build
pods
for
for
building
in
cncd,
but
for
development.
So
that
means
I
get
a
shell
where,
in
that
shell,
all
the
same
tools
that
the
CI
CD
pipelines
are
using
are
available
for
me
to
develop
with.
So
it's
the
exact
same
version
of
mirror
and
this
exact
same
version
of
how
I'm
and
get
and
scaffold
and
all
of
the
different
tools.
A
So
I
don't
have
to
keep
maintaining
an
install
on
my
laptop
with
all
the
tools.
I
need
the
dev
pod.
Just
has
everything
automatically
configured
for
you
right,
so
I
don't
need
to
run
all
those
tools
locally,
so
the
dev
pod
started.
That's
awesome!
So
if
I,
if
I
look
in
the
current
directory
and
now
in
a
what
that
commander's
dog
is
is
ran.
A
def
pod
are
now
opened
my
shell
in
the
dev
pot.
So
it's
a
bit
like
sshe
into
a
pod.
A
So
we've
now
got
a
new
terminal
where
we
can
run
build
commands
inside
the
cupola
t's
cluster
right,
so
I'm
not
running
docker
daemon
on
my
laptop
right.
I
have
no
and
I
kind
of
stopped
using
command
laptop.
It
is
kind
of
horrible
really,
so
I
can
type
like
docker
PS.
Now
this
docker
PS
is
listing
all
of
the
docker
containers.
That's
running
in
kubernetes
right
I
have
no
docker
binary
on
my
laptop
I'm,
just
using
it
in
the
cluster,
so
that's
kind
of
cool.
A
Now
one
of
the
issues
is
I've
no
source
code,
yet
I've,
just
booted
up
an
empty
def,
pod
right
and
there's
no
source
code
in
there.
So
what
we
can
do
is
if
I
go
into
another
shell
or
by
the
way,
I
think
we
always
not
quite
ready.
Yet
0:02
is
out
soon.
If
I
go
into
go
cube,
column
that
was
it
and
I
tank
JX
sink.
A
What
JX
Inc
is
gonna
do
is
it's
going
to
install
and
configure
a
piece
of
software
called
K
sync
casing.
Killers
is
an
open
source
tool
which
can
synchronize
source
code
from
your
laptop
into
a
kubernetes
pod
which
can
really
help
if
you
want
to
edit
on
your
laptop
in
your
IDE
and
run
it
inside
the
kubernetes
cluster.
So
we've
started
up
casing
so
now,
if
I
go
back
to
this
I'll
pop
that
terminal
back
open,
if
I
go
back
here
and
I
do
LS,
al
I
start
damn
okay
early
one.
A
A
If
this
works
is
gonna,
be
awesome,
honestly,
it's
gonna
be
really
really
good.
Let's
see
if
this
works,
oh
yeah,
okay,
any
moment
we'll
still
have
some
source
code
there.
At
least
I
could
know
that
was
close,
yay,
okay,
there's
almost
Oscar,
so
here's
the
source
code
in
the
pod
in
kubernetes
right,
so
we've
got
a
container
in
Google
Cloud
with
maven
and
go
and
a
bunch
of
other
maven.
A
We've
got
go
and
it's
got
cube
Caudill
and
it's
got
helm
and
it's
got
scaffold
installed
and
there's
a
little
shell
script
in
there
which
I'll
cap
first.
So
you
can
see
it.
It's
a
tiny
little
thing
that
just
runs
make
and
then
runs
this
tool
called
reflex
that
just
watches
this
for
source
code
changes
and
then
just
runs
make
again
so
for
type
watch.
Well,
this
is
going
to
do
now.
Is
it's
going
to
build
the
go
binary
for
that
from
the
source
code?
A
Then
the
make
file
is
going
to
make
a
docker
image
using
scaffold.
So
you
can
see
it
was
quite
quick
that,
but
it
made
the
docker
images
pushed
it
to
the
registry
and
it's
deployed
it
with
helm,
so
that's
kind
of
cool
and
then,
if
I
do
in
another
window
here
I'll
do
this.
One
JX
get
app
jacket.
App
shows
you
all
of
the
apps
you're
running
and
each
environment
they're
running
inside.
So
you
can
see
I'm
running
something.
A
Is
they
always
Arizona
Tuesday
surging
awesome,
so
zeros
over
to
sin
staging
so
that
should
be
awesome.
Yeah,
that's,
definitely
awesome,
and
then
you
can
see
this.
You
see
this
edit
namespace
here
edit.
So
that's
where
we're
running
our
edit
version
now
right
now,
that's
the
same
string
right,
it's
the
same
string.
But
what
we're
going
to
do
now
is
we're
gonna,
try
edit
the
code
just
before
I.
Do
that
I'm
gonna
open
the
terminal
I
have
to
forget
about
open
terminal
is
in
the
thing
and
I'm
gonna
copy
and
paste
this
URL
here.
A
If
this
demo
works
I'll
be
amazed,
but
let
let's
see
how
it
goes
so
I've
got
a
little
shell
script.
That's
just
gonna
curl
the
public
URL
of
this
service.
It's
just
a
little
shell
script
that
does
occur
every
couple
of
seconds,
so
I
can
see
the
output
of
the
code.
Now
what
I'm
gonna
do
is
I'm
gonna
make
this
demo
really
awesome,
so
I've
changed
some
source
code
on
my
laptop.
A
This
is
where
we
see
how
well
the
user
networks.
Oh
is
worked
awesome.
So
what
I
did
is
I
changed
some
source
code
in
vs
code,
vs
code
then
automatically
saved
the
source
file.
K.
Sync
then
synchronize
that
into
the
build
pod
reflex
in
the
build
pod
then
detected.
The
source
code
have
changed
and
rebuild
the
docker
image
and
then
redeployed
it
and
then
do
you
see
the
really
awesome
output.
So
we've
changed
the
code
on
my
laptop
in
my
desktop
IDE
and
have
the
running
live
in
Google
Cloud
within
a
couple
of
seconds
right.
A
That's
pretty
odd
that
they
saw
reworked
at
the
weekends
right
over.
This
is
a
very
recent
thing,
but
it's
a
really
awesome
way
of
developing
in
the
cloud
right.
If
ever
you've
tried
to
develop
docker
on
your
laptop
and
and
docker
push
on
your
laptop
when
you
sat
there
for
five
hours,
while
it
pulls
everything
from
the
internet,
you
kind
of
want
to
develop
in
the
cloud
as
much
as
you
can
right.
We
all
we're
all
trying
to
go
as
fast
as
we
can
and
minimizing
waste
is
a
good
option.
A
So
don't
run
things
on
your
laptop
on
a
pretend
kind
of
pretend
version
of
kubernetes
use
the
real
production,
kubernetes
cluster
or
development
cluster,
and
build
and
run
everything
there
so
you're,
always
using
the
same
version
of
Linux
you're,
always
using
the
same
containers,
the
same
version
of
docker,
the
same
systems.
Thus,
a
load
balancer,
the
same
disk
you're,
always
testing
on
as
close
to
production
as
possible
right,
which
means
you
go
faster.
A
You
don't
waste
time
fixing
a
threading
bug
that
only
works
on
that
only
breaks
a
Mac
OS
or
something
like
when
everything
in
Linux
and
containers
all
the
time.
Okay,
that
was
pretty
good.
So
just
to
recap,
what
we've
done
so
far,
one
command
creates
a
new
project,
sets
up
CI
and
CD.
It
gives
us
pull
requests.
A
It
gives
us
preview
environment,
so
we
can
validate
any
change
before
we
merge
when
we
merge
a
release,
is
then
automatically
promoted
using
detox,
so
everything
is
version
to
get
get
is
basically
your
database
and
where
everything
is
stored,
so
everything's
versions-
and
you
know
what
what's
going
on,
then
we
can
use
def
pods.
If
you
wish
to
edit
code
on
your
laptop
synchronize
it
to
the
cloud
and
redeploy
on-the-fly.
This
magic
is
using.
A
Another
covers
project
called
the
Google
open
source
called
scaffold,
so
you
can
actually
just
release
yourself
in
scaffold,
just
touch
scaffold,
dev
and
that
basically
really
watches
everything
in
the
source
code
and
redeploys
on
the
fly.
Whenever
that
changes
right,
which
is
pretty
awesome,
so
that's
most
a
quick
overview
of
Jenkins
X,
here's
a
couple
more
things,
so
I
went
for
coming
called
cloudBees.
We're
like
the
Jenkins,
the
commercial
Jenkins
company
and
everything
you've
just
seen
is
all
completely
open-source.
It's
all
mostly
apache
license,
but
it's
all
open
source.
A
You
can
download
it
and
play
with
it.
My
demos
almost
finished
so
feel
free
to
download
the
Jenkins
x
right
now
and
then
spin
up
a
cluster
and
have
a
go
so
everything's
up
the
source
up
to
now,
I'm
just
going
to
show
you
a
couple
of
things
which
are
open
source
which
are
like
commercial
add-ons
we're
working
on.
This
is
an
early
preview,
but
I
just
thought:
I'd
show
you
it.
So
we
have
a
chat
bot
that
what
cheese,
Jenkins,
X
and
whenever
a
pipeline
starts
see
that
that's
the
chat
bot.
A
So
if
I,
let
me
do
a
quick
commit
which
shall
on
me
and
let's
go
into
this
one.
So
you
go
Q,
Khan
and
I'll.
Do
a
git
commit
am
I
the
same
Oh
once
I'm
something
git
push.
Then.
If
I
go
back
to
my
browser
really
quickly
another
a
pull
request
window
this
one.
If
I
go
there
and
then
I
need
to
go
into
the
cheese
branch
and
I
click,
the
pull
request,
thingy,
we
so
need
a
pull
request.
Commanded
Inc
is
X
to
avoid
this
thing.
A
A
While
that's
churning
along
we'll
see,
we
should
see
a
pipeline
trigger
I'll
keep
talking
well,
while
this
runs,
but
you
should
see
basically
about
the
release.
Pipelines
should
trigger
and
you'll
see
it
all
kind
of
tinker
through
on
slack
now,
one
of
the
kind
of
nice
things
is,
if
you're
the
team
and
you're
making
loads
of
apps,
you
can
kind
of
see
releases
fly
by
and
whenever
there's
a
release
you
can
see.
For
example,
oh
hey
that
this
application
is
in
staging
there
or
that,
what's
the
pull
request,
you
just
raise
this
that
one.
A
A
You
have
lots
of
pipelines,
lots
of
environments,
he's
kind
of
hard
to
keep
all
this
stuff
in
your
head,
like
I've,
got
five
environments
now
and
I've
got
like
20
pipelines,
running
and
people
doing
pull
requests
left
right
and
center.
So
we
found
ourselves
with
like
50
browser
tabs
up
and
trying
to
keep
track
of
everything.
That's
going
on,
so
we're
building
this
kind
of
single
pane
of
glass.
A
That
just
gives
you
a
nice
simple
way
of
looking
at
everything
that's
happening,
so
I
can
see
my
staging
environment
and
for
each
staging
environment
for
each
app
in
each
book.
Excuse
me,
for
each
app
in
staging
I
can
see
all
the
activities
that
happening
on
that
bill.
They
can
see.
A
pipeline
is
running
right
now,
for
example,
so
0
0
2
is
released.
A
We've
triggered
zeros
over
3,
so
0
3
is
being
released
right
now,
and
Lync
should
appear
fairly
soon
to
link
to
0:03,
so
I
know
what's
happening
on
that
app
and
here's
some
existing
pull
request.
That's
going
on
so
I
can
look
at
the
different
pull
requests
and
each
of
these
I
can
look
at
the
apps
as
well.
So
it's
a
nice
simple
way
of
looking
at
everything.
That's
happening,
looking
what
pods
are
being
used
by,
what
app
what
resources
are
being
used
and
so
on
so
forth
and
fairly
soon.
A
We
hope
to
have
a
nice
simple
preview
UI,
for
if
you
want
to
do
manual,
promotion
and
what
we
kind
of
hope
is
eventually
people
automate
everything
right.
We
want.
We
want
most
things
to
be
automated
out-of-the-box
Jenkins
X
automatically
promotes
the
staging,
but
we've
left
promotion
to
production
as
a
manual
thing
by
default.
You
can
edit
this.
You
can
add
a
remove
environments
whenever
you
wish,
so
your
team
might
want
six
environments,
you
might
want
a
staging,
a
pre
prod,
the
production
you
might
want
to
soak
testing
load
testing
environment.
A
You
can
have
as
many
environments
as
you
wish.
Each
environment
you
can
see
if
it's
manual,
promotion
or
automatic
if
it's
automatic
promotion
the
pipeline
for
your
app,
will
promote
your
app
for
you.
If
it's
manual,
you
can
use
JX
promote
on
the
command
line
to
manually,
do
a
promotion,
we're
hoping
in
this
UI
to
have
a
really
slick
promotion
wizard.
A
So
if,
if
you
do
go
with
manual
promotion,
you
can
just
use
this
nice
little
UI
and
just
click
promote
and
it's
kind
of
nice
and
simple,
and
so
you
don't
have
to
use
the
command
line.
All
the
time,
so
that's
almost
it
for
today,
I
had
to
ship
speed
this
up.
Quite
a
bit.
Cuz
I
thought
this
was
an
hour.
I
was
going
to
spend
an
hour
talking
about
all
this
stuff.
It
is
it's
a
five
minute,
so
I
apologize
for
that
and
we've
just
about
got
time
for
questions.
A
Great
question:
how
heavily
tied
in
is
it
to
github
the
we
have
a
git
plug-in
that
lets
us
use
different
get
providers
today,
github
and
github
enterprise
work
awesome
and
we
have
support
for
bitbucket
and
get
lab
and
get
here,
but
they're
not
quite
awesome
and
working
yet
we're
working
on
it
and
we
hope
it
works
soon.
But
right
now,
it's
not
quite
there,
but
if
you
want
to
use
a
different
get
provider,
just
let
us
know
and
help
us
getting
working
yeah
and
thank
you.