►
From YouTube: Jenkins X: Easy CI/CD for Kubernetes with Jenkins
Description
Slides: https://docs.google.com/presentation/d/1gXkshDLU6MI80j1biL3t9NjFwHatkFwJ8qjw6suzclg/edit
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. https://jenkins-x.io/
After a short introduction James will spend 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! Let's go faster!
About our speaker, James Strachan:
James works on CI + CD for Kubernetes with Jenkins for CloudBees. He's the lead architect of Jenkins X.
He also created the Groovy programming language, Apache Camel & was a founder of fabric8 & ActiveMQ.
A
B
Sure,
let's
just
stop
my
slides,
because
I
I'll
end
up
telling
you
about
that
in
like
to
be
sliced
time,
let
me
set
the
scene
a
little
bit
before
I
talk
about
Jackie's
ex
tracker,
so
I
wanna
give
a
little
bit
of
background
about
the
problems
that
people
have
and
then
I'll
introduce
James
X.
So
let
me
do
a
quick
step
back.
So
a
lot
has
happened
in
the
last
five
years
about
how
we
build
software
package.
It
release
it,
deploy
it
manage
it
right.
B
If
you're
trying
to
be
a
high-performing
team,
almost
everything
has
changed
in
what
you
should
be
doing
these
days.
Okay,
so
there's
a
huge
move
from
on-premise
to
public
cloud.
That's
been
going
for
probably
about
a
decade,
but
it's
really
exponentially
ramping
up
in
the
last
few
years,
it's
much
easier
to
elastically
scale
your
infrastructure
on
the
cloud
rather
than
guessing
whether
Hardware
you're
gonna
need
X
next
year
and
then
buying
office
space
and
machines
and
doing
your
own
kind
of
private
datacenters.
B
So
this
is
big
move
to
the
public
cloud
and,
in
addition,
there's
this
big
move
away
from
virtual
machines
to
containers
and
the
main
reason
for
that
is
really
just
cost
container
is
smaller
uses
less
CPU
disk
memory
than
a
virtual
machine.
So
traditionally,
we've
often
used
virtual
machines.
It's
always
deploying
software
into
staging
in
production
environments.
Increasingly,
there's
now
an
economic
need
to
move
from
virtual
machines
to
containers.
So
that's
a
feather
big
change.
Then
in
Alaska
have
for
years
something
called
cube.
Annuities
has
come
along,
which
is
interesting.
B
The
industry
standard
way
of
orchestrating
contains
at
scale
communities
came
out
of
Google
and
it's
basically
an
implementation
of
what
Google
has
been
using
internally
for
about
a
decade.
Everything
at
Google
runs
on
the
container
or
in
the
container.
So
whenever
you
Google,
search
Google
Maps
anything
the
cook
of,
does
your
running
continue.
You're
using
containers
and
the
big
problem
we've
continues
is
how
do
you
manage
them
all
right
once
you
split
or
applications
into
lots
of
little
containers?
How
do
you
keep
them
up
running?
How
do
you
do
load
balancing?
B
How
do
you
scale
up
and
down?
How
do
you
make
sure
they're
all
running
all
the
time
and
they
can
all
talk
to
each
other
and
so
far,
and
that's
really
what
kubernetes
does
and
why
Kuban
it
is
exists,
and
this
year
2018
is
basically
the
year
that
kubernetes
will
Cuba.
Natives
has
become
these
standard
way
of
running,
contains
and
scale
on
any
cloud
right.
B
There's
a
public
cloud,
private
cloud,
whether
it's
your
laptop
in
2018,
all
the
major
cloud
providers
will
have
something
called
and
managed
to
cuba
Nittis
as
a
service
and
what
that
basically
means
is
this
year
you
can
pick
any
reasonably
popular
cloud
provider.
Certainly
the
big
three
in
the
Western
world
and
Alibaba
in
China,
so
you'll
be
able
to
go
to
Google
and
Microsoft
Amazon's
website
and
say:
please
give
me
a
Cuban
80s
cluster
and
you
pick
how
big
the
cluster
is.
B
How
many
nodes
you
wish
to
use,
how
big
the
nodes
are
and
so
forth,
and
then
the
public
cloud
vendor
will
manage
Cuba
Nittis
clusters
for
you
they
will
keep
those
nodes
running.
If
a
node
fails,
they
were
what
imagine
to
restart
them.
You'll
be
able
to
elastically
scale
the
cost
of
up
and
down
to
your
heart's
desire
and
you'll
be
bitterly
billed
in
terms
of
how
much
compute
nodes
you
use
and
computing
and
memory
in
this
key
use.
In
many
ways,
Cuba
natives
on
the
public
cloud
is
basically
free.
B
Now
I
could
completely
managed,
hosted
people
80
services,
basically
free.
You
just
pay
for
the
compute
disk
and
network
of
your
actual
containers
that
you
run
on
kubernetes,
which
is
pretty
cool.
So
this
huge
change
from
on-premise
the
public
cloud
from
VMs
the
containers
and
the
move
to
keep
annuities
and
as
lots
the
complexities
for
developers
like
not
many
developers
even
know
what
keeping
it
is.
Easy
has
never
mind
how
to
use
it.
B
Well
then,
in
addition,
there's
this
huge
movement
in
the
IT
world
to
move
away
from
111
micro
services
and
we're
all
trying
to
become
high-performing
teams.
So
we
we're
trying
to
figure
out
how
to
develop
software
quickly
and
deliver
business
value
to
customers
as
quickly
as
possible,
so
that
we
can
get
feedback
and
we
can
iterate
right.
B
So,
rather
than
spending
years
in
an
ivory
tower
working
on
a
huge
monitor,
if
we
want
to
create
a
little
microservices
and
get
them
in
front
of
users
really
quickly
and
get
feedback
and
then
iterate
quickly
and
quickly,
so
we
basically
won't
continue
to
depression,
introduce
delivery
with
containers
on
Cuban
80s
on
any
Cuban.
If
this
cluster
public
or
iPod,
which
is
a
kind
of
a
nation
right,
this
is
suddenly
there's
all
this
stuff.
We
all
have
to
do
so.
If
you're
a
team
right
now
who's
trying
to
deliver
software
value
to
your
customers.
B
You
have
all
these
things.
You
need
to
figure
out.
You
need
to
figure
out
how
to
set
up
your
communities
cluster,
how
to
set
up
your
environments,
like
development
testing,
staging
production,
how
to
move
your
software
into
containers,
how
to
deploy
those
containers
on
cuban
et's,
keeping
it
easy
uses.
This
ya
know
stuff
for
generating
deployment
descriptors,
and
then
this
is
other
thing
called
helm
shirts,
which
is
seen
as
the
canonical
way
of
packaging
applications
for
Communities
howlings.
Like
a
package
manager
for
communities,
then
people
need
to
figure
out.
How
are
you
gonna?
B
Do
continuous
delivery
and
promote
released
applications
between
testing
staging
and
production
and
then
with
this
thing,
called
get
ops.
That
is
a
term
that
we'd
works
folks
made
of
last
year,
which
is
a
really
good
term,
that
increasingly,
when
we
start
to
do
high
performance,
high
performing
teams,
and
we
trying
to
do
operational
stuff
like
how
do
we
manage
what's
running
in
a
staging
environment
or
what's
running
in
your
production
environment?
My
common
practice
is
get
ops
which
basically
means
store
all
of
your
environment.
B
Specific
configuration
can
get
so
everything's
versioned
and
audited
and
has
history
so
then
you've
ever
somebody
makes
a
change
in
production,
then
make
a
change
through
gate
not
directly
with
the
production
system,
so
that,
if
all
of
a
sudden
production
goes
pear-shaped,
you
can
just
look
who
did
the
last
community
production?
Maybe
we
should
blow
that
one
back,
because
that
might
fix
the
problem.
Soget
ox
is
the
new
hotness
in
how
to
do
operations.
So
we've
got
the
cube
identities,
the
containers,
the
moving
to
he'll,
move
into
cookies
delivery,
adopting
guitars.
B
Then
we
need
to
automate
everything,
because
we
need
to
spin
lots
of
different
micro-services
whenever
we
feel
like,
so
we
can
do
experiments
and
then
we
need
to
get
the
feedback
back
to
the
development
team
from
all
of
this
kind
of
stuff.
Now,
once
we
figured
out
all
of
that
stuff,
we
then
need
to
actually
do
the
business
value
that
we're
meant
to
be
doing
in
the
first
place.
So,
basically,
today
we
have
all
this
stuff.
B
It's
trying
to
optimize
all
of
that
kind
of
stuff
to
help
you
get
going
quickly
right.
So
what
does
Jenkins
X
do
for
you?
So
the
first
thing
Jenkins
X
does?
Is
it
configures
a
whole
bunch
of
tools?
One
of
the
lovely
things
about
communities
is:
there's
a
massive
vibrant,
open
source
ecosystem,
one
of
the
downsides
of
keeping
it
is
what
tools
should
you
pick
and
how
should
you
plug
them
all
together
to
get
a
fast,
efficient,
yeah
see
ICD
experienced
all
right.
So
what.
B
Is
the
total
thing
ten
working
with
the
open
source,
where
you
have
a
lot
of
options
right,
exactly
and
Jenkins
is
notoriously
challenging
in
that
world
as
well?
You
have
faced
with
Jenkins.
Often
traditionally
is
there's
2,000
plugins
or
a
thousand
plugins,
which
ones
are
the
ones
that
you
think
you
need
for
your
use
case,
like.
A
B
What
Jenkins
our
jockey
sex
does
a
few
things.
What
Jenkins
X
does
is
it's
an
opinionated
choice
of
open
source
solutions,
plus
Jenkins
X
integrates
them
all
together
for
you,
so
rather
than
even
having
to
Google
on
the
Internet.
How
should
I
do
say
I
can
see
when
you
find
a
bazillion
different
tools
that
do
a
piece
of
the
puzzle.
What
Jenkins
X
is
trying
to
do
is
glue
all
of
the
best-of-breed
tools
together
into
one
simple
to
install
package.
B
Learning
also
takes
care
upgrading
these
tools,
because
each
one
of
these
tools
has
its
own
release
cycle
right.
So
there's
tools
like
Helmand
scaffolds
and
Nexus
and
monocular
there's
a
whole
bunch
more.
Each
of
these
tends
to
have
a
fairly
rapid
release,
schedule
and
changes
quite
frequently,
so
another
thing
too
is
aekta
does
is
it
takes
care
of
upgrading
so
that
as
new
versions
of
scaffold
comes
out
or
helm
or
Nexus
on
the
macula
table,
chart
museum
and
various
other
bits,
pieces,
plus
J,
Keys,
X
itself
and
Jenkins
itself?
B
Yes,
so
he
does
do
that,
which
is
a
good
thing.
So
that's
a
good
thing
and
then
the
other
thing
is
goes
he's
not
just
integrate
all
those
tools
together.
He
then
alternates
how
you
set
up
no
CI
NCD
pipelines
for
your
actual
applications
that
you're
building.
So
as
soon
as
you
have
an
application,
you
might
be
created
from
scratch
and
I'm
importing
it
from
some
source.
You've
got
and
get
somewhere.
B
You
might
be
using
a
QuickStart
or
whatever,
as
you
bring
an
application
to
the
table
and
Jenkins
Tech's
will
automate
setting
up
the
pipeline
to
do
cont
e
it'll
automate,
creating
the
bucket
images
and
it
will
automate
creating
the
helmet
chance.
So
will
basically
automate
the
CI
into
these
stuff
using
best
practices
for
how
we
should
be
doing
this
on
kubernetes
like
which
is
using
git
ops
for
promotion
in
it's
using
a
clean
master,
so
Mass
as
always
releasable.
B
It
uses
somatic
versions
and
every
release
which
we'll
see
in
a
moment
so
is
using
git
up
to
do
all
the
promotion.
So
we
release
everything
once
with
a
unique
version
number,
and
then
we
move
that
package,
the
culture
and
those
docker
images.
We
move
them
from
testing
to
stage
into
production
through
this
get
ups
process
virtual.
Well,
we
see
a
demo
of
how
that
works
in
them
in
a
few
minutes
and
I
can
show
you
a
bit
more
behind
the
curtain.
What
actually
happens
when
all
that
kind
of
stuff
happens?
B
A
A
B
B
I
mean
we're
actually
using
Jenkins
X
to
build
Jenkins,
X
and
lots
of
pieces
of
Jenkins
X
out
like
libraries
and
NPM
packages
and
docket
images
and
stuff
which,
by
themselves
they
don't
go
to
stage
of
in
production.
So
you
can
use
Jenkins
X,
just
as
a
way
of
releasing
things,
but
the
the
promotional
side
of
things
that
the
continuous
delivery
that
the
de
piece,
the
conducive
livery,
that
kind
of
assumes
you're,
delivering
the
software
somewhere
and
so
for
continuous
delivery.
Jackie's
ex
assumes
that's
the
Cuban
eighties
cluster
of
some
kind.
B
We
are
working
on
some
service
stuff,
some
if
you're
doing
service
but
you're,
not
using
Cuban,
instead
replacing
you're
more
using
something
like
lambda
on
the
Amazon
or
something
like
open
fares
or
Q
plus,
or
something
like
that
on
communities.
Possibly,
we
hope
hope
to
have,
particularly
for
those
but
we're
not
really
addressing
things
like
folks
who
want
to
deploy
virtual
machines
onto
some
infrastructure
as
a
service
kind
of
provider
or
some
VMware
thing,
EEO,
OpenStack
or
whatever
right.
We
don't
really
focusing
in
longer
term.
B
We
could
look
at
extending
Jenkins
X
to
handle
things
like
terraform
or
ansible,
or
something
that
that's
the
deployment
side,
but
we've
not
really
looked
at
that
yet
because
we
we
feel
that
cuban
ities
is
going
to
be
a
pretty
big
deal.
It's
the
preferred
way
of
deploying
containers
on
all
the
three
major
clouds
already
Red
Hat
promotes
Cuban.
It
eases
the
way
of
deploying
containers
on
RedHat
operating
system.
How
foundry
supports
cube
annuities
as
a
preferred
way
in
Cuban
is
they're
pretty
much
everybody
even
Dhaka
supports
it.
B
B
However,
obviously
Jenkins
can
do
anything
he
wanted
to
do
so,
as
always
Jenkins,
if
you
know
using
communities,
but
dick
is
actually
very
much
cubans
focus
for
now
for
them,
okay.
So
the
next
thing
is
this
all
sounds
kind
of
cold.
So
how
do
we
get
started?
How
do
we
set
up
a
Cuban,
eighties
thingy,
and
how
do
we
put
chickens
eggs
on
it?
So
the
first
thing
you
need
to
do
is
get
your
binary
tool
called
GX
for
Jenkins
X.
B
If
you
click
that
URL
or
if
you
go
to
the
Jenkins
X
website-
and
there
were
a
couple
of
clicks,
you
can
download
the
binary
yourself,
it's
a
fairly
small
binary
and
you
just
need
to
put
it
in
your
path.
It's
a
static
link
binary,
so
you
can
install
it
on
pretty
much
any
operating
system
and
it
just
kind
of
works
and
if
you're
using
a
Mac,
you
can
use
blue
to
install
it.
B
If
you
prefer,
if
you're
on
Linux,
you
can
copy
and
paste
those
commands
if
you
prefer,
or
you
can
just
download
the
binary
from
the
github
website.
So
once
you've
got
this
binary
and
you
put
the
binding
me
on
your
path,
you
then
need
to
run
one
command
to
either
install
and
create
a
cluster
ijq
Beneatha's
cluster
who
Jenkins
X
on
it,
or
if
you
already
happen
to
other
communities
cluster,
you
can
run
the
second
command
J
X
install.
So
the
first
command
is
what
we
prefer
you
to
use.
B
It's
J
X
then
create
then
cluster.
Then
the
next
argument
on
the
command
line
is
the
kind
of
cluster
you
want
to
make.
So
AWS
is
for
Amazon,
which
uses
cops
under
the
covers
to
spinner,
for
keeping
it
is.
Cluster
GK
is
for
Google,
which
is
a
really
really
nice
way
of
winning
cubed
integers
right.
Now,
though,
Jiki
seems
to
be
a
little
bit
ahead
of
all
of
the
public
clouds
today,
but
I
my
sermons,
you're
catching
them
quickly
and
then
aks
is
if
you're,
using
Microsoft
Azure.
A
B
You
can,
as
many
cube,
we
actually
recommend
you.
Don't,
though,
to
be
honest
just
because
so
many
people
have
tripled
in
a
mini
queue,
because
many
cube
depends
on
virtualization
on
your
machine
depends
on
bits
of
docker
from
Mac
or
Windows
running
people
have
so
many
issues
running
mini
cube
on
their
laptop,
so
it's
kind
of
quite
surprising
how
many,
how
much
issues
people
have
with
it.
So
I
honestly
recommend
people
try
the
public
cloud.
They
all
have
three
tiers.
Yes,
you
need
to
register.
B
I,
don't
know
about
you
at
home,
I've
got
pretty
lousy,
wife,
I
doing
docker
bills
and
downloading
docker
images
and
stuff
on
my
laptop
takes
like
forever,
whereas
I
can
spin
up
a
cluster
on
Google
in
like
two
minutes,
I'm
ready
to
run
right
on
my
laptop.
It
takes
like
an
hour
and
an
every
dollar
bill
takes
like
20
minutes
because
he's
downloading
the
Internet
into
my
laptop
so
I.
We
do
really
recommend.
If
you
can,
please
try
the
public
code.
A
B
Exactly
so,
we
do
recommend,
if
you
can,
if
you
possibly
can
try
the
public
cloud
plus
we
kind
of
want
you
to
use
this
for
real,
so
we
kind
of
rather
try
not
in
a
public
cloud
if
you
like
it,
keep
using
it
and
your
team
now
have
a
cncd
platform.
You
can
use
for
real,
no
one's
going
to
use
your
laptop
for
real
for
CNN
CD
on
the
team
right.
A
B
A
downloads
and
things
like
that
under
and
the
lack
of
lack
of
web
hooks.
Yes,
so
you
can
manually
keep
triggering,
builds
yourself
because
there's
no
kind
pox
on
mini
queue,
but
yes,
so
create
a
cluster,
preferably
on
the
public
cloud.
But
if
not,
you
know,
it's
fine
use,
Jake's,
install
or
use
many
cube.
Instead
of
a
in
create
cluster,
you
can
do
jxk
cluster
mini
queue,
I
think
that
was
kind
of
work.
If
mini
cube,
works
on
your
laptop
assuming.
B
A
B
All
right
and
there's
all
kinds
of
I
mean
with
lots
of
people,
have
tried
doing
attacks
with
mini
coop
and
had
loads
of
failures
with
it,
and
it's
always
to
do
with
many
hoping
not
to
do
with
the
local
configuration.
Basically
yes
like,
like
which
version
of
vagrant
to
hyper
kit
and
docker
for
Mac.
Have
you
got
on
your
laptop
and
all
those
kind
of
things
so.
A
B
B
A
B
Edit
so
pick
one
of
these
that
you,
like
you,
think
you
bees,
okay,
we
but
we'd
rather
use
a
public
cloud.
Okay,
I
have
a
real,
quick
video
of
what
it
looks
like
to
install
on
Google,
but
they
all
pretty
much
look
about
the
same
I'll
just
hit
play.
This
is
slightly
sped
up,
so
your
basic
type
Jake's
create
cluster
gke.
B
I
did
want
to
do
a
live
demo
of
this,
just
because
it's
kind
of
boring
because
he
doesn't
really
do
very
much
and
it
it
takes
like
two
to
three
minutes
and
you
mostly
sat
there
waiting
for
the
cloud
to
spin
these
things
up,
but
basically
you
type
in
Jake
to
a
cluster
de
hit
return.
It
asks
you
for
which
nodes
you
wish
to
use
in
which
regions
it
sets
up
something
covered
in
grass
with
like
a
load,
balancer
thingy,
installs
Jake
is
X
and
all
the
various
pieces.
Then.
B
Finally,
you
can
just
see
the
last
piece.
It
creates
two
git
repositories
which
will
come
on
to
leather
when
we
do
the
demo
to
git
repositories
which
are
used
for
get
ops
which
are
your
staging
and
your
production
environments.
Git
repository,
which
those
things
will
become
clear
when
I
start
actually
an
endemic.
So
what
does
it?
What
does
that
give
me
like?
If
I
do,
if
I
create
cluster
with
Jenkins
X?
What
do
you
get
its
each
team
gets
OH.
B
In
other
words,
whenever
your
team
asks
to
do
a
build
for
whatever
reason
so
you
commit
to
master
or
you
create
a
pull
request
or
whatever
and
a
build
will
be
triggered
automatically
using
Cuban
ities
as
a
scheduler.
So,
rather
than
having
like
a
fixed
number
of
agents
or
whatever
in
Jenkins,
we
use
the
Cuban
entities
plug-in
for
Jenkins
under
the
covers,
so
that
each
team
has
an
elastic
node
pool
of
agents
which
is
limited
only
on
your
the
capacity
of
the
cuban
''tis
cluster.
B
So
long
as
you
have
capacity
given
it
is,
you
can
run
a
build.
Each
team
also
gets
their
own
monocular,
which
is
like
an
epic
app
store
thingy.
Then
each
team
also
gets
their
own
staging
environment
and
production
environment,
and
what
that
basically
means
is
each
team
can
release
apps
to
their
staging
environment
without
asking
for
approval,
without
you
know,
raising
tickets
and
getting
different
people
to
let
them
in
so
it
means
from
a
from
a
classic
microservices
world.
B
These
environments
are
completely
isolated
so
that
you
can't
accidentally
use
the
production
database
for
your
tests
or
something
when
you
drop
the
database
in
your
test,
harness
you
don't
accidentally
do
that
on
the
production
database
and
vice-versa.
So
it
gives
you
that
level
of
isolation
between
environments,
even
within
the
same
team
and
then
each
team's
environments,
are
these
isolate
from
each
other
too.
B
So,
if
you
have
like
ten
teams
all
showing
the
same
cluster
and
you're
not
going
to
interfere
with
each
other
directly,
okay
right,
what
I'll
probably
do
now
is
do
a
live
demo
in
this
case
on
Google
cloud
and
I'll.
Do
a
live
demo
of
creating
an
app
on
on
Jenkins
X,
and
then
we
could
walk
through
and
see
so
you
can
see
how
it
all
works
and
how
we
can
automate
CI,
NCE,
so
I'm
in
a
little
command-line
shell.
Here
we
have
a
little
command.
A
B
A
B
B
Okay,
that'll
work,
yeah
all
right
cool,
just
let
me
make
it
bigger
wider,
so
this
is
rapper,
horribly
epileptic,
Jay
King.
If
it's
not
solidly
yeah
ruptal
it'll
be
hungry.
Let
me
to
make
it
slightly
bigger
citizen
R
up
to
Brandon
there
we
go
that,
doesn't
look
too
bad,
okay
cool.
So
here's
all
my
environments
that
I've
got
right
now,
so
the
development
environment
is
the
first
line.
That's
where
the
software
tools
run
like
Jenkins
and
there's
other
things.
B
I
have
something
called
an
edit
environment
which
is
where
and
I'll
show
you
that
right
at
again,
but
that's
where
I
can
develop.
I
can
I
can
work
on
things
inside
my
IDE
that
only
I
can
see,
and
then
we
have
the
team
staging
environment
and
team
production
environment.
I'll
talk
a
little
bit
about
what
those
are
and
how
they
work
they're
there,
but
first
what
we're
going
to
do
is
create
a
new
application.
B
Now
we
support
a
whole
raft
of
different
languages
and
libraries
and
frameworks
and
stuff
I'm
going
to
start
with
a
spring
boot
application
just
because
spring
boogies,
one
of
like
the
most
popular
framework
of
the
Java
ecosystem.
If
you're
going
to
make
a
micro
service
these
days,
people
typically
tend
to
reach
the
spring
boot
first.
So
what's
that
with
the
spring
boot,
so
there's
a
command
JX
create
spring
and
what
they
still
is
under
the
covers.
B
Is
it
uses
something
called
start
dot
spring
dye,
oh
that
the
spring
folks
create
so
there's
this
spring
star
initialize
it
with
juice
like
a
wizard
that
lets
you
spin
up
new
spring
boot,
micro-services
and
I
get
to
choose
which
programming
language
I
wish
to
pick
and
I'll
go
with
Java,
which
group
ID
dollars
to
use
I'll
just
use
default.
What's
the
name
of
my
app,
let's
call
a
webinar
great,
but
there
we
go
there's
a
handy
name.
Now
it's
asking
is:
this
is
just
been
bootleg.
Now
it's
asking
is
which
spring
boot
dependencies?
B
B
All
right,
let
me
do
that.
One
more
time
forget:
you
saw
that
I
would
let
around
and
subdue
before.
This
will
be
done
and
I
forgot
to
switch
back
to
the
right.
No
space,
okay,
try
again
and
we'll
call
this
duty
from
the
time
did
the
dip
the
depths
that
one
group
artifact
ID,
will
call
this
roping
James
actuator
and
the
web
yeah
there
we
go
even
that's
better
and
then
it's
gonna
have
to
do.
We
want
to
initialize
it.
Yes,
we
do
so.
This
is
the
these.
B
Are
the
files
and
it's
created,
which
is
basically
the
same
things
that
start
up
spring.
The
I/o
would
create
if
you
went
through
this
stuff,
dot
spring
Diane
website
and
what
its
gonna
do.
Is
it's
copied
these
files
into
my
local
file
system
in
this
directory,
and
now
it's
going
to
add
them
into
a
git
repository
which
is
cool,
so
excited
the
kit
repository
now
it's
runs
something
called
a
build
pack
and
it's
added
in
a
bunch
of
extra
files
to
enable
things
like
building
things
with
docker
there's
a
docker
file.
B
He
says
they're
things
like
a
Jenkins
file.
I'll
talk
about
these
files
in
a
moment
now
it's
asking:
where
should
we
store?
They
skip
your
positi
in
a
git
server
and
so
he's
asking
is
on
github.
Where
do
you
want
to
store
it
and
I'll
starting
my
personal,
and
it's
going
to
use
that
repository
name
and
so
now?
What
it's
going
to
do
is
it's
pushing
during
a
get
pushed
it's
going
to
create
a
new
repository
on
github
and
it's
now
you're
going
to
get
touched
on.
B
Take
github
now,
if
I
type
a
copy
and
paste
this
command
here,
it's
gonna
copy
and
paste
that
straighting
well,
that
commands
going
to
do.
Is
it's
going
to
visualize
what
pipelines
are
happening
in
my
project
to
the
terminal?
So,
as
things
happen
on
that
project,
it
will
just
echo
to
the
screen.
So
as
a
before
this
demo,
we'll
see
things
happen
on
that
terminal.
Okay,
so,
what's
happening
on
the
covers
you
see
a
pipeline
is
triggered.
So
what
we
did,
click
on
this
URL,
so
gonna
get
cheating
ready.
B
So
this
is
to
get
repository
I've
just
created
there
we
go
so
it's
a
normal
get
repository
with
the
normal
Java
stuff,
there's
a
comics
ml
there
with
normal
Pollock's
ml
stuff.
So
that's
a
normal
spring
boot
QuickStart,
which
is
based
on
the
canonical
source.
Currently,
if
I
just
look
in
the
source,
this
is
a
normal
source
code
of
a
typical
spring
boot
camp
right.
It's
not
totally
expecting
it's
just
a
vanilla,
empty.
B
But
a
few
other
things
we
talked
of
how
we
turn
this
source
code
into
a
docket
image,
but
that's
the
docker
file
which
was
generated
for
us
from
the
build
pack.
We
also
added
the
Jenkins
file,
which
is
a
declarative
file
that
describe
all
the
steps
we
need
to
make
to
run
the
CI
and
the
seeding
pipeline
right.
We
don't
need
to
worry
too
much
about
the
contents
of
that
then,
under
the
covers.
We
also
created
this
charts
folder,
which
is
the
helm
charts
for
packaging,
the
application
up
and
deploying
it
on
to
cube
annuities.
B
So
we've
added
a
bunch
of
these
files
into
get
for
you,
so
we
have
a
whole
range
of
build
packs
which
automate
building
docker
images
and
CIN
CD
pipelines
for
those
kind
of
programming
languages,
whether
it's
Python
or
Ruby,
or
go,
or
no
js'
or
Gradle
or
maven
with
every
date.
So
we
have
all
these
different
bill
packs
that
autumn
a
master
for
you,
so
you
don't
need
to
worry
about
it
in
so.
A
B
B
Yeah,
so
we
add
all
these
files
in
for
you
and
then
we
automate
so
what
we
kind
of
did
there
I
tried
one
command
which
created
this
application,
so
in
one
command,
J
X
quit
spring.
We
created
you
get
repository
source
code
inside
him.
Well
that
also
they've
done
the
covers.
Was
he
added
some
web
hooks
if
event
to
the
settings
and
we
look
at
web
hooks
we'll
see
it's
registered
a
web
hook.
B
That
says
whenever
we
do
a
push
or
any
of
the
branches
trigger
Jenkins
and
to
do
the
CI
in
the
CD
I'm
also
noticed
that
it
looks
like
we've
started
to
do
promotion,
so
that
means
we've
built
a
release.
So
if
I
click
on
the
releases
tab
notice,
we've
got
0
0
1,
so
we've
tacked
the
source
code.
That
0
is
everyone,
so
we
can
now
look
at
the
exact
version
of
code
that
is
being
built
to
the
0
0
1
and
we've
generated
some
release.
B
It's
gonna
generate
as
soon
as
there
were
2
and
then
3
it's
using
the
get
tags
in
the
pit
repository
to
keep
track
of
what
version
has
been
released
so
that
if
ever,
we
wish
to
jump
from
0,
0
1
to
say
1,
0
0
we
just
create
a
get
tag
old
ones
and
0,
and
then
the
next
release
will
be
1,
0
1.
Another
way
you
can
force
the
version
version
numbering
scheme
is
you
can
edit
your
pom.xml
and
by
default
the
version
says:
0
0,
1
snapshot.
B
If
you
edit
that
to
be
1,
0
0
snapshot,
then
the
next
release
will
start
with
a
1
right.
So
you
can
use
the
pom.xml
or
the
package
listen
to
define.
What's
your
major
minor
version
numbering
otherwise,
it
will
just
assume
everything's
a
kind
of
a
patch
release
right.
So
we've
built
the
release:
we
version
Devery
0:01
we've
built
a
docker
image,
we've
built
a
hound
chart
and
released
those
so
zero
zero
one
is
now
a
mutable
version.
B
As
you
can
see,
here's
a
reserved
one
is
an
immutable
version
that
you
can
now
use
in
any
cuban
eighties
cluster
anywhere,
but
now
we're
doing
this
github
thing
where
you
see
there's
a
pull
request
being
generated.
Let
me
click
on
that.
I
click
on
the
pull
request.
This
is
a
pull
request
to
promote
zero
zero
one
into
the
staging
environment
notice,
we're
in
the
staging
environment,
J
strike
and
test3
is
the
name
of
my
customer.
So
that's
the
name
of
the
get
environment.
B
What
this
is
doing
is
it's
generating
a
pull
request
on
the
environment
and
don't
worry
too
much
about
the
details.
This
is
the
change
required
to
add
this
new
application
into
a
ham
jar.
But
what's
interesting
is
we're
not
copying
the
docker
image
and
we're
not
copying
the
blob
enamel
of
ever
that
we're
copying
a
reference.
The
version
number
two,
a
hound
chart
that
we've
released
into
this
chart
museum
repository.
B
So
this
is
a
little
bit
like
updating
upon
X
amount
of
other
dependency,
where
you're
adding
a
dependency
by
name
and
version,
so
we're
adding
a
new
dependency,
webinar
gems
and
we're
adding
0
0
1
as
a
pull
request
and
I.
Think
that
poor
request
should
hopefully
merge
for
anything
what's
happening
is
notice
that
there's
a
CI
job
he's
now
running
on
the
stage
during
development
to
validate.
Is
this
quarry
quest
on
the
staging
environment
valid?
So
it's
running
whatever
our
CI
tests
for
this
stage
of
the
environment
to
test
things
like?
B
Has
the
stock
image
being
pushed
to
the
docker
registry?
Is
this
how
much
are
available
in
the
Hancock
repository
you
may
wish
to
add
other
validations
to
your
CI
pipeline,
like
has
all
the
docker
images
passed,
the
NEC,
the
even
ability
checks
or
whatever
else
you
wish
to
check,
for
you
might
also
need
to
add,
say
human
approval.
Like
do
we
need
a
couple
of
plus
ones
on
this
to
say
you
can
promote
this
version
that
they
SAP
into
the
staging
one.
B
Yes,
so
I
didn't
explain
this
yet
I
should
explain
a
bit
better,
so
there's
a
cup
of
different
ways
in
which
approvals
can
happen.
So
by
default,
each
team
gets
a
staging
environment
and
a
production
environment,
and
by
default
we
set
up
promotions
automatically
on
staging
and
manually
on
production.
So
whenever
we
do
a
release
by
default
automatically,
we
generate
we
promote
that
to
a
staging
environment,
but
we
leave
promotion
to
the
production
environment
as
a
manual
step
that
you
choose
when
you
want
to
do
that.
B
In
addition,
because
some
of
the
covers
get
ops
is
using
git,
we
use
pull
requests
to
generate
everything
and
those
poor
requests.
Depending
on
the
configure,
your
get
your
posit
Ori,
you
can
have
automatic
or
manual
approvals
on
the
merge
operations,
so
you
can
set
up.
You
know,
I
need
two
plus
ones
before
you
can
merge
these
public
ways
and
you
can
leave
the
merge
side
of
a
public
quest
to
be
a
completely
manual
things
you
can
choose
when
you're
happy
to
merge
those
things
and
by
default,
that's
also
automatic
as
well,
and
hopefully.
A
A
B
Puck
gets
to
the
pipeline
UI
for
the
staging
environment.
You
can
see
that
this
is
just
about
friend
that
this
is
finished,
so
it's
gone
in
green
and
so,
if
I
reload
this
page,
hopefully
this
should
merge
soon,
I'm,
not
sure
why
it's
not
going
green
on
the
github
yet
any
moment
now
github
should
realize
this
is
mobile,
and
it's
because
it's
green
I
can
see
it's
good
there.
We
go
it's
green
so
any
moment
now
they
should
have
their
github
becomes
web
page
and
it
should
merge
I'm
just
going
to
click
the
merge
button.
B
A
B
B
Evening,
stay
tuned,
get
people
okay.
So
now,
if
I
look
at
the
staging
repository
and
we
look
inside
the
requirements-
which
are
basically
all
the
hats
which
is
deployed-
we'll
see
we-
we
now
save
webinar
James,
there
was
a
one
he's
one
of
the
apps.
So
now
another
pipeline
is
gonna
run,
which
is
going
to
apply
these
changes.
So
it's
basically
gonna
save
to
helm.
B
So
if
any
engine
now
this
on
the
staging.
So
this
is
the
master
branch
on
the
study
room
so
hopefully
soonish
this
pipeline
should
show
the
long
and
then
they
should
apply
0
0
1
into
this
staging
environment.
And
again
usually
this
is
a
little
snappier.
So
hopefully
that
will
kick
off
so
we're
gonna.
Take
there's
a
limitation
there.
B
B
Phil,
green,
that's
also.
Okay,
that's
agreed
so
hopefully,
if
this
UI
should
update
very
soon
because
it's
gone
green
and
if
I
go
back
to
my
other
terminal
there
we
go
this.
So
it's
promoted,
we
could
see
it's
promoted,
the
z1
is
promoted
and
oh
I
wasn't
scrolling
the
screen.
That's
where
handy
and
there's
the
URL,
if
I
click
on
that
URL
and
any
minute
now,
that's
just
starting
up
in
Cuban
AP.
So
this
is
the
URL
of
the
app
that's
running
in
the
staging
environment,
with
a
few
moments
to
start
up.
B
If
I
go
to
my
other
terminal,
which
I've
hidden
slightly
under
that
window,
you
move
that
down
here.
If
I
type,
K
X
get
that
this
will.
It's
me
all
of
my
apps,
all
of
my
environments,
so
I
might
have
five
different
apps
somewhere
in
staging
some
in
production,
they're
all
different
versions,
this
little
command
Jegs
get
get
app.
Lets
us
see.
I've
got
zero
zero
one
in
the
staging
environment,
there's
no
pulse
running
just
yet.
It
should
be
soon
if
the
pubs
are
up.
B
So
if
I
click
on
this
URL
various
now,
this
doesn't
look
too
impressive.
This
page
this
is
this,
is
actually
a
working
page.
Just
might
not
look
it.
This
is
what
the
spring
but--at
generates
by
default,
because
there's
no
code
in
it,
so
it
doesn't
know
how
to
render
anything,
which
is
why
it
returns
a
formal
form
and
what
I'll
do
now
is
I'll.
Show
you
how
a
pull
request,
works
and
we'll
do
a
pull
request
on
this
application
and
we'll
see
how
pull
requests
were
cooking.
These
X
and
we'll
hopefully
make
this
page.
A
A
B
A
B
Exactly
exactly
so,
we,
the
other
thing
to
bear
in
mind,
is
what's
quite
common
in
teams
is
they'll
often
sit
there
on
the
laptop
hacking
away
for
a
while,
until
they're
ready
to
show
it
to
someone
else
and
then
we'll
go,
or
does
he
see
from
working
Cuban,
AIDS
I,
don't
know,
I
haven't
even
tried.
Yet
what
we're
trying
to
do
is
make
people
go
to
the
other
way
like
it's
before
you
even
start
coding.
B
So
what
what
I'm
just
doing
I've
just
created
a
little
branch
I'm
using
command
line,
get
branch
get
check
out,
I've
added
a
file.
If
I
do
get
adds
result?
Is
it
step?
Is
there
have
I?
Didn't
you
file
and
I'm
gonna?
Do
a
git
commit
I'll,
do
everything
on
the
command
line,
because
some
people
sometimes
get
a
bit
confused
with
you
without
ease?
B
Let's
go
fix
that
homepage
there
we
go
and
get
push,
and
so
I've
done
a
get
pushed
on
a
branch.
So
if
I
go
back
to
this
gate,
depository
and
then
we'll
see,
that
github
is
saying,
would
I
like
to
make
a
pull
request
so
I'll
say
well
yeah
unless
people
request
and
let's
submit
a
pull
request,
so
I've
just
used
get
here,
I
haven't
done
anything
magical
or
weird
I've,
just
done
a
normal
good
thing.
I've
used
the
normal
github
web
page
to
requests
pretty
much.
B
You
trust
the
dip
in
that
the
files
changes.
Yes,
yes,
so
I've
literally
just
added
a
new
HTML
file.
That's
all
I've
done.
I've
got
a
new
father
into
this
static
index
variable,
so
I've
just
added
the
file,
not
the
best.
If
you've
ever
seen,
I
should
have
maybe
modify
the
file,
but
NASA
then
encourage
you.
Our
infirmities.
B
So
notice
the
pipeline
is
triggered
because
we're
in
a
pull
request.
Now,
if
you
remember
20
minutes
ago,
we
did
the
JX
create
spring
and
that
create
a
new
project
which
is
a
spring
grew
up
and
he
said
of
the
pipeline,
the
pipeline
angles
pull
requests
and
releases.
So
whenever
you
could
submit
a
pull
request
in
this
project,
it
will
run
a
poll
request
pipeline.
That
validates
is
your
purchase.
Valley,
do
all
you
of
your
test
pass
and
whatever
kind
of
code
quality
validations
you
wish
to
use
one
other
thing.
B
We
do,
though,
with
Jenkins
X.
If
you
do
something
called
preview
environments
or
by
the
way,
you'll
notice
on
here,
we'll
see
the
pull
request
pipeline
is
checking
one
here
right,
so
we
can
see
pull
request
pipelines
as
well
as
master
branch
pipelines.
So
what's
actually
happening
under
covers
is
we're
running
all
the
usual
stuff.
We're
really
the
unit
test
check
the
base
pass.
Then
what
happens?
Is
we
create
a
preview
docker
image
of
the
Chico
change
before
it's
merged
to
master
right?
B
So
what
we're
gonna
do
is
we're
gonna,
create
a
preview,
docker
image
and
then
what
we're
gonna
do
is
spin
up
a
preview
environment
to
run
that
preview
image,
then
we're
gonna
spin,
all
of
that
up
in
kubernetes
and
then
we're
gonna
comment
or
request
with
a
link
to
where
the
apps
running
in
the
preview
Martin.
Now
the
reason
we're
doing
this
is
is,
for
various
reasons.
Imagine
you're
building
were
building
a
web
application.
It's
quite
common
for
teams
to
do
things
like
code
review
of
us
as
pull
requests
come
in.
B
You
might
want
to
get
your
peers
to
review
your
changes
if
you're
changing
a
web
application
looking
at
the
diff
can
be
kind
of
confusing.
Seeing
a
diff
in
a
CSS
file
doesn't
really
give
you
an
idea
for
how
how
well
a
new
feature
looks
in
an
IDE
in
a
web
browser.
So
the
idea
behind
preview
environments
is
it
does
two
things
it
lets
you
test
the
application
that's
run
before
you
agree
to
merge
it.
B
So
if
you're
trying
a
new
like
Buy
It
button,
you
can
let
your
team
members
review
what
it
looks
like
before.
You
agree
to
merge
it,
so
it
gives
you
a
place.
You
can
have
a
better
discussion
on
the
pro
requests
about
what
you
think
of
a
feature
by
seeing
it
run.
Another
thing
you
can
do,
though,
that
the
preview
environment
acts
as
a
check
that
goes.
Does
this
change
actually
still
work
in
cuban
--'tis?
It's
surprisingly
easy
to
make
a
Kircher
such
as
adding
a
new
mandatory,
adding
a
new
mandatory.
B
That
that,
if
that
environment
variable
isn't
also
set
inside
the
home
Church,
your
app
now
fails
and
Cuban
TVs.
So
it
adds
an
extra
level
of
testing
that
goes.
Does
your
app
still
work
on
Cuban
ities
before
you
merge
it
and
if
I
look
at
the
floor
request
and
see
how
it's
gone
green,
because
all
the
checks
passed
but
also
notice.
This
comment
here
it
says
a
pull
request
is
built
and
is
available
in
the
premium
element
here
and
it
gives
you
a
link
to
a
URL
which
is
also
the
link.
That's
on
the
screen.
B
Here's
a
swim
URL
then
I'll
click
it
on
the
progress
because
it's
kind
of
cool.
So
if
I
click
that
the
URL
will
see
well
web,
the
pod
starts
up.
It's
not
quite
started
yet
in
a
few
moments,
we'll
be
partnered
up
and
running
because
he
adds
the
link
before
it's
checked
it.
So,
oh
there
we
go
it's
up
so
notice
that
in
the
URL
we
have
the
organisation
name,
the
repository
name,
pull
request.
One
preview
is
add
name
space
or
the
place
in
which
this
runs.
So
each
pull
request
gets
its
own
environment.
B
Where
we
can
access
this
application-
and
this
is
basically
the
HTML
page
addition
of
a
so
this
is
the
new
home
page,
so
you
can
verify
yes,
this
does
look
good,
or
at
least
it
looks
lots
better
than
what
we
have
before.
So
we
can
have
prove
this
pull
request
after
testing
it
out,
and
we
can
say
yes
before
I-
do
that
as
well.
We
can
type
a
xscape
app
and
we
can
see
these
are
the
application
that
we
can
do.
Jx
get
preview
and
we
can
see
these
are
all
the
pull
requests.
B
So
here's
the
pull
request,
I've
just
done
and
that's
where
it's
running
so
we
can
easily
as
a
team,
modify
and
view
all
the
pro
requests
that
happening
and
validate
them.
And
then,
when
we're
ready,
we
say
most
omastar.
Now
we
merging
that
code
change
into
the
master
branch
and
now
hopefully
another
release
pipeline
will
kick
off
there.
We
go
so
version.
2
is
now
zero.
Zero
two
is
now,
and
so
this
virtually
is
now
going
to
get
released
and
be
deploying
into
the
staging
part
and
that'll.
B
Yeah,
so
so,
just
to
recap:
we've
just
seen,
because
it's
maybe
slightly
confusing
I'd
be
flipping
between
a
few
different
consoles
and
looking
at
the
browser
a
little
bit,
we
turn
to
one
command
to
create
a
brand
new
micro
service
and
that
immediately
was
released.
It
was
built
and
released
with
a
semantic
version
and
then
promoted
to
the
staging
environment
automatically
through
a
pull
request.
Then
we
created
the
pull
request
ourselves
on
that
app.
B
That
then
generates
a
preview
environment,
so
we
can
test
out
the
application
before
we've
merged
it
and
then,
when
we
merge
it
with
n
releases
of
the
two
so
we've,
basically
automated
CI
and
CD,
without
as
a
user
you
having
to
worry
about
what
the
jenkins
file
is
or
a
docker
file
or
a
helper
or
even
what
given.
It
is
a
couple
of
other
details
about
this
before
we
maybe
go
into
more
questions
is
the
other
thing
to
remember
it.
Well,
Jenkins
X
is
automating
all
of
this,
for
you,
Jamie's
ex,
isn't
actually
hiding
anything.
A
B
B
So
we
can
imagine
people
tweaking
the
bill
packs
a
little
bit
so
that
they
could
Faulk
our
get
deposited
with
a
Bill
pack
same
make
a
few
modifications,
as
you
know,
add
some
build
packs,
remove
some
bugs
modify
them
a
little
bit
so
the
organization
at
an
organization
level
people
can
modify
those
a
little
bit.
We
obviously
want
to
try
and
get
as
much
reuse
as
we
can
throughout
everyone
in
the
industry.
So
we
want
to
avoid
people
just
creating
their
own
brand
new
build
packed
in
isolation.
B
If
ever
you
create
a
build
pack
for
other
milsim,
really
ancient
version
of
WebSphere
or
something
we'd
love
it.
If
you
contribute
that
backup
to
the
community,
so
we
can
all
share
it.
But
if
you
really
want
to
do
anything
local
within
your
company,
you
know
crack
on
and
it's
all
good.
So
we
hope
to
have
a
nice
diverse,
rich
community,
around
the
bill
PACs
themselves,
but
worst
case
you
can
just
modify
directly
inside
your
application.
If
you
wish
got
it
okay,
so
that's
kind
of
CIN
CD
so
that
well
the
over.
B
Do
a
staging
poll
request
for
this?
For
your
change
just
be
coming
up,
it's
it
should
be
coming
up
very
very
soon.
I
should
show
you
by
the
way
one
common
question.
I
get
you
never
assured
this
is
people
say.
Are
you
hiding
there
Jenkins
console
at
the
answer
is
well
no,
but
what
we
trying
to
do
is
is
make
it
easy
for
people
to
develop
without
necessarily
having
to
keep
going
back
to
the
Chinese
consul
all
the
time,
but
you
can
do
a
command
J
Copeland
Jenkins,
which
dolphins
are
taking
his
console.
B
So
if
ever
you
want
to
just
look
in
k-means
console,
you
can
just
do
that
and
if
I
go
into
my
pipeline
will
see,
the
master
branch
is
chugging
along
and
it's
now
running
the
promote
stage.
So
it's
made
the
release
and
it's
now
running
a
command
called
Bay.
Its
promote,
which
is
the
motion.
I
should
have
mentioned
this
before
asleep.
B
If
ever
you
want
to
manually
promote
something
you
can
just
type
Jake's
promote
mention
the
application
name
and
the
version
you
wish
to
promote,
in
which
environment
you
wish
to
promote
it
to,
and
you
can
just
promote
that
application
to
the
staging
or
the
moment
on
demand
Jegs
promote,
can
also
promote
any
application.
So,
whether
it's
an
application,
you
build
yourself
like
a
custom
micro
service,
or
it
could
be
something
that
comes
from
the
community
like
Prometheus
or
elasticsearch,
the
farmer.
B
So
we
can
do
promotions
using
the
JX
command
line
ourselves
outside
of
CATV
if
we
wish,
and
so
that
promotion
is
chugging
along,
so
we
should
see
a
pull
request
there.
We
go,
there's
a
pull
request.
So
what's
interesting
about
these
public
questions,
because
now
this
is
version
zero
to
the
diff
is
going
to
be
much
smaller.
Now,
remember
the
first
pull
request.
We
saw
had
three
lines
changed
because
we've
never
deployed
the
application
before
now.
All
we're
doing
is
changing
the
version
from
zero
zone,
one
to
Salem
to
write
R.
B
Then
it
may
be
in
in
two
weeks
from
now.
If
ever
you
decided
you
wish
to
rollback,
you
can
either
use
the
j8
remote
command
winder
to
roll
back
a
version,
or
you
could
literally
just
do
a
pull
request
directly
in
the
github
web.
Console
could
literally
just
edit
that
version
number
back
deserves
our
one.
A
B
Or
command
line
your
trace?
Yes,
exactly!
Yes,
whichever
you
like,
we
are
working
on
a
whole
bunch
of
IDE
plugins
as
well
for
vs
code,
intelligent
clips,
so
that
if
you
want
to
stay
in
your
IDE
of
choice,
hopefully
you
can
do
more
of
that
from
just
in
your
IDE
rather
than
having
to
you
know,
use
custom
tools
or
you
might
just
notice
that
pull
requests
merged
so
I
think
fairly
soon,
we
should
have
that
release
choking
in
the.
B
B
So
if
we
go
back
to
lose
track
of
my
windows
here,
we
go
so
hopefully
we'll
see.
This
is
the
staging
environment,
scape
depository
in
Jenkins,
and
now
the
push
to
master
pipeline
is
the
master
branch
pipe
on
use,
then
running,
so
hopefully
that
that
should
start
soon
there
we
go.
It
started
so,
hopefully,
in
a
few
seconds
that
should
be
applied
and
they
won't
have
servers
of
a
team
in
stage
II
cool
there.
We
go
that
should
happen
really
soon.
B
A
B
What
we
want
to
do
is
go.
It
works
on
the
cloud
first,
that's
the
thing
that
we
care
about
more
than
anything
else
running
on
your
laptop
should
be
a
secondary
thing
that
we
should
look
care
less
and
less
about,
but
we
should
be
caring
more
more
about
it.
Does
this
run
on
in
a
docker
container
in
Cuban?
It
is
using.
B
B
What
I'm
going
to
do
is
I'm
going
to
switch
to
another
shell,
what
they
put
it
here
and
I'm
going
to
open
an
IDE
I'm
going
to
use
the
it
code
for
this
demo
and
we're
working
on
an
eclipse,
plugin
and
BS
code
and
IntelliJ
and
vs
code
is
the
one
that's
slightly
further
ahead
than
all
the
others.
This
application
is
an
OG
xed
application,
just
to
kind
of
show
that
we
can
work
with
node.
B
We
can
work
with
girl
become
on
jar
with
spring,
with
maven
riddled
with
perl
PHP
Python
Ruby,
rust,
all
kinds
of
different
stuff.
So
this
is
a
very
simple.
This
is
even
simpler
than
the
previous
example.
This
is
a
very,
very
simple,
no
GS
application
that
basically
serves
a
file
like
this
that
it's
not
going
to
make
you
lots
of
money
if
you
copy
this
much
service.
This
is
not
the
world's
most
interesting
micro
service,
but
I
want
to
show
you
how
you
can
develop
in
the
cloud
while
using
your
laptop.
A
A
B
Bigger
he's
up
pick
it
up
yeah
yeah
in
this
one.
You
don't
have
to
notice
too
much
about
what
what
sucks
you
in
the
screen,
but
what
I'm
gonna
do
is
I'm,
opening
up
the
command
window
in
the
vs
code
and
I'm
gonna.
Do
this
dev
card
command,
so
there's
there's
something
in
giggy's:
X
called
a
death
pod.
So
let
me
open
the
death
pod
terminal
and
then,
while
it's
running
I'll,
explain
what
else
you
happen
under
covers.
So
what
this
is
doing
is
right.
B
Let
me
step
back
a
little
bit,
so
I
can
explain
this
ci
in
CD
in
Jenkins,
X
uses
something
called
a
build
part.
So
basically
it's
a
pod,
which
is,
you
are
group
of
containers
which
contains
all
the
software
tools
for
doing
CNN
CD.
So
in
a
node.js
application,
that's
going
to
have
node
and
NPM
and
get
and
cube
CTL
and
a
bunch
of
other
kind
of
tools.
If
you're
doing
math
and
stuff
it
will
have
maven
installed
and
yabber
and
get
some
various
other
things.
B
So
we
have
these
different
docker
images
with
all
the
tools
you
need
to
do.
Conc
D
right-
and
these
are
all
versions
and
managed
by
Jenkins
X.
Well,
the
bad
part
is,
is
a
pod,
a
container
that
you
can
use
in
development
which
has
all
the
same
tools
inside
so
in
fact
out
here,
I
can
type
NPM
version
and
there
I
can
see.
Npm
ins
in
this
container
and
I
can
type
in
git
and
I
can
type
in.
B
You
can
see
I'll
get
from
the
example,
so
I
can
run
all
of
these
different
tools,
which
you
need
to
work
closely
on
communities
if
you
wish
right.
So
we
have
basically
a
container
here,
but
this
looks
like
it's
running
on
my
desktop,
but
actually
this
term
low
is
running
in
a
pod
inside
cube
annuities
right.
So
this,
therefore,
is
a
terminal
into
a
container
in
communities
so
inside
this
tunnel,
I
can
run
stuff
in
the
cloud
as
if
it's
kind
of
on
my
laptop
right.
B
So
it
feels
like
it's
laptop,
but
it's
not
it's
all
burning
in
McClaren,
so
this
means
I,
don't
have
to
install
node
myself
at
that
install
get
or
make
or
any
of
the
tools
that
say
on
city
use.
Right
I
can
just
share
the
same
tools
that
CI
and
see
the
is
using
and
maintaining
the
other
thing
it's
doing
if
I
do
and
that's
AF,
here's
all
the
source
code
in
this
part.
Now
this
source
code
is
synchronized
from
my
desktop
into
the
content
in
the
communities
cluster.
B
So
what
that
means
is
I
can
edit
everything
on
my
laptop
in
my
desktop
IDE,
but
I
can
compile
and
build
and
use
it
inside
the
clap-
and
let
me
do
a
quick
example
to
show
you
what
I
mean
with
a
little
charger
called
watch
and
it's
what
command
is
gonna
build
off
the
docket
image
and
then
deploy
that
application
into
my
personal
anymore
right.
Then
it's
gonna
watch
the
source
code
for
changes
right.
Let
me
pop
to
another
terminal
and
if
I
tackle,
let
me
go
into
another
terminal.
B
There
we
go
everywhere
if
I
type
jxk
tap
can
see.
We've
now
got
in
my
local
environment.
I've
got
a
new
URL
for
where
this
is
running
in
my
personal
namespace.
So
this
is
the
application
in
the
building
right
now,
which
I
can
browse
it
in
my
window.
Well,
I'm
also
going
to
do
is
I'm
going
to
run
the
little
command
to
just
curl,
which
URL
have
a
couple
of
seconds
and
outputs
the
message
from
this
HTML:
okay,
so
I'm
just
curling
this
microservice
in
my
personal
namespace.
B
So
while
that
curls
with
you
I'm
going
to
go
back
to
my
editor
and
I'm,
going
to
edit
the
HTML
page
and
I'm
going
to
say
hello
world
from
awesome,
I've
tried
the
word
awesome
and
you
know
if
you
see
the
bill.
That's
just
rebuilt
in
this
terminal
down
here
what
happened?
There
is
I
typed
in
my
IDE,
my
IDE
synchronized,
that
source
code
change
into
the
pod.
B
That's
running
in
communities,
but
then
kicked
off
a
docker,
build
to
really
build
that
container
image,
but
then
read
applied
the
hunter
and
then
any
moment
now
this
curl
command
should
return
the
new
text,
hopefully
once
a
little
bounce
of
there
we
go
awesome.
So
what
I
did
is
I
did
a
build
in
the
public
cloud
and
then
did
a
rebuild
when
I
changed
the
code
and
he
rebuilt
in
like
five
seconds
right.
B
So
so
it
took
the
service
down,
brought
it
back
up
and
in
the
new
floor
exactly
in
a
new
phone,
so
it
means
we
can
make
any
change
to
the
source
code,
whether
it's
the
front
end
code,
the
back
end
code,
the
dockerfile,
the
the
hound
chart.
We
can
make
any
change
but
like,
and
this
will
redeploy
on
the
fly
to
my
person
environment
quickly.
Now
I
did.
A
B
And
so
the
idea
of
these
development
environments
is
this
is
where
you
can
just
run
stuff
without
before
you
ready
to
do.
Git
commits
in
progress
when
you
want
to
do
a
real
preview
environment
with
a
reflect
real
public
image
and
whatnot.
That's
when
you
do
a
pull
request
at
this
stage,
you're
just
doing
a
really
quick,
rebuild
and
redeploy
locally,
and
then
it's
up
to
you
what
else
you
want
to
use
in
your
personal,
no
space,
you
can
link
to
other
services
from
external.
B
Let
me
do
another
one,
really
awesome.
Let's
a
couple
of
seconds
later
it
we
built
there.
We
go
now
turn
about
you
when
I
build
it
up
image
on
my
laptop,
it
takes
a
very
long
time
right
inside
the
public
cloud.
This
is
fast.
This
is
like
a
couple
of
seconds,
and
it's
already
we
done,
and
hopefully
this
show
I
wasn't
scrolling
all
to
the
pond.
There
we
go.
It's
really
awesome
already
right,
so
that
was
like
what
four
seconds
five
seconds
right
all
right
now,
what
we're
doing
right
now
is
actually
a
brute-force.
B
Every
time
you
Eddie
the
source
code,
we're
actually
rebuilding
a
docker
image
from
scratch
and
redeploy
in
a
new
version
of
the
part
of
the
new
version
of
unit,
we're
hoping
to
optimize
this
much
quicker
so
that
you
could
get
even
faster
tournament
time.
So
you
type
something.
For
example:
we've
nerd!
You
don't
really
need
to
rebuild
a
docker
image
each
time
you
can
literally
just
start.
No,
then
watch
more
than
just
copy
the
files
into
that
container
and
you
don't
have
to
stop
and
start
the
application
right.
B
That's
all
for
different
programming
languages
and
frameworks.
We
can
go
much
much
faster
than
this,
but
this
is
just
a
quick
example
of
how
you
can
use
the
same
tools
that
CIN
CV
is
using
in
development.
If
you
don't
have
to
worry
about
maintaining
the
same
version
of
node
on
maven
or
Jaguar
whatever
on
your
laptop,
but
also
you
can
do
really
fast.
Incremental
builds
in
the
cloud
right.
I
never
use
docker
on
my
laptop
anymore.
It's
just
way
too
slow
and
error-prone.
B
If
ever
you
do
a
docker
build
you're
pulling
huge
amounts
of
images
down
to
your
laptop
and
then
you
have
to
do
a
docker
push,
which
is
really
slow
and
you're
pushing
gazillions
of
bytes
back
up
to
the
cloud
which
is
really
slow.
If
you
do,
your
daughter
builds
inside
the
cloud,
it's
usually
really
really
fast
and
then.
B
B
If
you
a
node
person
now,
the
modules
could
be
massive,
correct
way
to
do
like
NPM
install
locally,
so
you
just
have
been
ever
so
slightly
careful
that
you
really
are
synchronizing
the
source
code
you
want
to
sync
Church
is
all
defined
by
this:
a
magic
file
SD
ignore
which
takes
care
of
all
that
for
you.
But
yes,
so
there
we
go.
So
that's
a
quick
test
of
doing
development,
and
so
what
we're
really
trying
to
do
with
jank
is
X
is
we're
trying
to
optimize
all
or
every
unexpected
software
development.
B
Our
initial
focus
is
very
much
about
how
do
we
automate
CIN
CD
on
kubernetes,
with
multiple
environments,
with
promotion
through
guitars
and
how
to
automate
all
that
stuff
for
you?
But
we
also
very
much
want
to
help
people
in
the
development
phase
right
so
make
it
easy
for
people
to
test
things.
Build
things
incrementally
change
their
code
and
over
time
we
want
to
increase
this
scope
and
make
a
much
more
powerful
and
rich
environment
so
that
people
can
basically
be
productive
with
the
cloud
developing
software.
B
A
Yep
all
right
well,
actually,
this
is
okay.
Main
point
here
is
that
Jenkins
acts
here
are
some
links
for
you,
the
the
Jenkins
xio
a
website
to
try
it
out
or
gain
context,
dot,
io
community
to
get
feedback,
there's
a
slack
channel,
and
you
can
also
we,
which
is
a
what's
here,
and
you
can
also
really
the
Academy's
website
pages
that
cloudBees
come
KX
to
get
other
information.