►
Description
Sagy Volkov, architect, demos how OpenShift Container Storage 4 persistent storage can help Jenkins run faster.
Learn more: openshift.com/storage
A
So
there
are
a
lot
of
scenarios
where
Jenkins
can
use
persistent
storage,
there's
just
too
many
ways
to
use
Jenkins
that
you
can
just
trim
them
down
into
one
of
two
methods.
Every
piece
of
software
or
application
that
is
being
built
in
it
is
using
Jenkins
is
different
from
the
another
one
using
different
plugins.
A
A
You
need
to
share
data
or
storage
between
all
your
pods,
so
you
can
use
surface
via
OCS
for
to
share
the
storage
between
all
these
sports
during
the
build
process.
Another
example
is,
if
you
are
getting
into
a
point
where
you,
the
build
process,
is
spawning
a
lot
of
pods
with
a
lot
of
a
persistent
volume
claims
or
pods,
but
that
needs
many
persistent
volume
claims
you
might
be
starting
to
hit
the
limits
of
what
your
cloud
provider
can
actually
provide
in
terms
of
mounting.
A
For
example,
AWS
ec2
has
a
limit
of
28
mounts
so
together
with
OCS
4,
you
can
overcome
these
limits.
The
third
scenario-
and
that
is
what
we
are
going
to
concentrate
on
a
demo-
is
where
we're
basically
using
the
persistent
storage,
some
sort
of
data
that
has
been
used
in
the
field
between
all
the
consecutive
builds
of
the
same
application
that
we
were
trying
to
test
and
build
what
we
are.
A
Software
itself
is
an
open
shift
project.
It's
it's.
It's
basically
building
a
Java
API
restful
web
service
for
some
sort
of
an
application.
The
code
is
not
really
what's
important
in
here.
What's
important
is
that
you
know
during
a
continuous
delivery
phase
of
development,
we
have
pipelines
that
usually
hold
there.
Four
stages
build
a
deploy
test
and
a
release.
Each
of
these
stages
depend
on
the
previous
one.
A
Each
stages
might
go
to
different
other
components
of
software
ship
information,
and
this
is
sort
of
the
pipeline
that
we're
doing
on
our
demo
we're
going
to
concentrate
on
the
build
portion
of
the
pipeline
in
order
to
show
how
we
can
save
time
during
the
build,
so
the
build
our
pipeline
itself
will
create
an
amazing
clone.
The
repository
of
the
open
ship
tasks,
project
built
the
artifact,
which
all
will
also
go
and
download
all
the
dependencies,
the
libraries
that
is
needed
and
end
the
build.
A
The
third
stage
is
where
we
are
actually
going
to
save
significant
amount
of
time
by
keeping
these
dependencies
and
libraries
going
from
one
build
to
the
next
bill
to
the
next
bill
to
the
next
build.
This
is
just
a
our
build
confirm
that
we
are
going
to
use
in
open
shift.
You
know
a
few
things
to
emphasize
on.
A
I
have
download
the
scripts
that
I've
shown
in
the
in
the
slides,
we're
going
to
deploy
Jenkins
the
script
itself
is,
has
five
functions
in
it.
We
create
a
project
where
we
want
to
deploy
Jenkins
in
it.
This
is
where
we
do
all
of
our
work.
We
create
a
Jenkins
app
using
the
OCE
new
app
method
and
we
then
wait
for
this
Jenkins
master
to
come
up
takes
roughly
between.
You
know,
sixty
two
hundred
twenty
seconds.
A
The
script
X
except
basically,
two
methyls
one
is
the
project
that
we
want
to
create
and
hold
everything
in
it,
and
the
other
is
some
kind
of.
Is
there
a
storage
class
that
we
want
to
create
the
PV
we'd
in
my
case,
I'm,
going
to
do
it
with
the
rooks
F
block,
so
I'm
going
to
run
the
script
and
we
are
going
to
do
a
little
bit
of
and
then
a
little
bit
of
a
time
wrap
and
then
back
soon.
A
A
So
once
a
build
finish,
the
second
one
starts
second,
one
finish
the
third
one
and
so
on,
and
we
will
see
the
time
difference
between
the
first
build
and
then
the
next
four
consecutive
builds
so
run
the
script.
We
just
need
to
provide
the
the
project
that
we
created
before
with
the
Jenkins
and
the
build
config
and
some
sort
of
a
directory
that
will
hold
the
output
from
all
the
builds
in
here
and
so
again,
we're
going
to
do
a
little
bit
of
a
time.
Wrapping
here
and
once
all
five
builds
are
done.
A
1
minute
and
55
seconds
and
every
other
bill
that
follows
is
dramatically
faster
because
when
the
build
process
starts,
we
identify
the
same.
Persistent
volume
claim
that
we
call
dependencies
in
our
maven
pod
it
and
see
is
that
all
the
dependencies
are
already
there,
so
it
immediately
jump
into
the
maven
build
section
of
of
our
code
and
it
completes
very
fast
now.
These
are
just
the
times
for
literally
what's
going
on
inside
the
maven
pod.
Once
it's
up
there's
another.
A
Time
consideration,
which
is
how
long
it
takes
to
Jenkins
to
start
the
build
and
create
a
maven
pods
which
is
coming
from
Jenkins
and
kubernetes.
This
is,
you
know
it's
out
of
our
control,
but
what
we're
showing
is
is
that
the
build
time
is
considerably
shorter,
once
the
first
build
actually
download
all
the
dependencies,
so
the
next
step,
I'm
going
to
actually
create
60
of
these
projects
and
using
another
another
script
and
then
run
60
of
these
builds.
A
A
A
The
average
is
about
91
seconds
and
the
second
builds
significantly
a
drop
into
eight
seconds
following
five,
five
and
four
seconds.
So
what
basically
is
demo
is
how
we
can
take
three
AWS
and
old.
All
this
open
chef
kostow
consists
with
three
workers
that
also
run
OCS
four,
so
it's
just
three
worker
nodes
and
we
run
sixty
Jenkins
pods
in
parallel
running
our
build
and
we
showing
that
even
on
either
a
multi
tenant
or
multi
group
environments.
A
We
all
see,
as
four
is
consistent
in
saving
the
time
in
this
type
of
build
type
by
saving
all
the
dependencies
and
libraries
just
again
to
sort
things
out
if
we
were
not
using
persistent
storage
from
LCS
for
the
90
seconds
will
actually
continue
to
be
the
average
to
be
laying
any
bill
that
we
will
be
running
so
we're
saving
a
lot
of
time
in
here.
I
hope
you
enjoyed
this
demo
and
the
links
to
the
scripts
over
there.