►
Description
Chris Blum, architect, demonstrates OpenShift Container Storage 4 stateful applications with Rails & PostgreSQL.
Learn more: openshift.com/storage
A
So
what
do
we
consider
traditional
state
file
applications?
These
are
applications
that
typically
store
stayed
and
rely
on
that
state
to
be
present.
So
these
applications
generally,
when
you
install
them,
have
an
interface
where
they
initialize
their
back-end
storage
and
typically,
if
it's
a
database,
they
put
in
tables
and
indexes
and
all
that
and
then
once
users
use
these
applications,
the
data
that
they
rely
on
it
grows
and
you
have
to
keep
it
since
they're
traditional
applications.
A
They
are
not
necessarily
aware
that
they're
running
inside
of
openshift
and
they
also
done
typically
leverage
open,
sherek
abilities,
api's
such
as
secrets
or
config
maps,
but
they
might
be
using
them
indirectly
without
knowing
that
they're.
Actually
using
them,
so
why
should
I
use
OCS
for
my
stateful
applications?
Ocs
has
a
very
easy
way
to
install
itself.
A
It's
built
upon
battle-tested
software
like
rogue
and
safe
that
have
already
been
used
for
many
many
years
by
customers
in
productive
environments,
and
it
has
been
shown
that
using
the
software,
it's
very
easy
to
scale
out
and
not
only
increase
the
capacity
which
is
easy,
but
also
increase
the
performance.
Almost
literally
then.
Obviously,
using
OCS
you
get
Red
Hat
support
and
since
that
software
Safin
ruk
start
software
is
it's
so
popular.
We
can
also
look
on
a
very
large
community
that
helps
us
in
certain
areas.
So
going
forward
with
the
demo.
A
Application
itself
is
not
stable
and
phosphorus
is
backed
by
OCS
to
retain
and
to
show
you
that
this
is
actually
true
we're
going
to
scale
down
the
application
in
the
end
to
simulate
fault,
and
then
we
scale
it
back
up
so
that
it
comes
back
up
and
we
show
that
our
data
is
actually
safe.
So,
let's
head
over
there
for
this
we're
going
to
use
this
example
here,
then
I've
prepared
and
we're
just
going
to
deploy
this
application
that
I
just
like
we
have
them
in
the
example
here.
A
With
the
OSI
status,
we
can
theoretically
check
on
our
application
and
we
do
see
that
it's
currently
still
new,
but
we
can
also
see
that
we
already
have
a
PVC
for
Postgres
database
and
that
is
already
bound.
Sir.
The
backend
storage
system,
which
is
backed
by
cefr
BD,
has
already
created
this
volume
and
it's
ready
for
the
pot
to
use
it.
So,
let's
check
how
far
the
deployment
this
already
okay,
so
our
Posterous
deployment
has
finished.
The
database
is
ready
to
be
used.
A
Rent
application
is
currently
in
the
build
phase
and,
as
you
can
see
in
the
guide
here,
half
the
bill
we
deploy
have
a
hook
and
then
we
actually
deploy
our
application.
So
we'll
come
back
in
a
second
okay,
as
we
can
see
now
the
Postgres
part
it
is
running
and
the
rails
application
has
gone
through
its
build
opponent,
hooks
it
up,
and
it's
not
also
running.
So
we
are
good
to
continue
and
to
continue.
We
will
figure
out
how
we
can
reach
our
application
by
checking
on
the
routes,
and
our
routes
looks
like
this.
A
A
So
this
is
our
first
state
as
you've
seen
we
have
gone
through
an
in
it
face
on
the
roads,
application
that
I've
prepared
the
Posterous
database
and
now,
as
we
use
it,
we
created
our
very
first
data
and
that
will
also
be
retained
in
a
postscript
database.
So
now,
let's
look
a
little
bit
more
on
our
storage
back-end
and
for
this
let's
first
get
an
overview
of
our
PVCs
resistant,
rolling
claim
that
we
already
saw
before
and
now
it's
names
phosphorus,
it's
bound.
It's
using
cell
RBD
to
look
at
settle
RBD
a
little
bit
closer.
A
This
is
how
we
get
in
there.
Then
we
execute
commands
like
SEF,
DF
or
Raiders
F,
which
will
both
give
us
a
good
overview
of
how
our
storage
is
used.
We
do
see
that
our
search
class
is
based
on
SSD
disks.
We
do
have
lot
of
ports,
but
we're
currently
only
interested
in
this
pool
because
it
matches
wide
the
storage
gas
is
using,
so
Safari
D
is
backed
by
the
safe
black
ball,
and
so
let's
look
at
the
images
that
are
inside
of
this
pool.
A
A
And
we
do
see
that
sizes
5
gigabytes,
so
this
is
very,
very
likely
our
image,
let's
all
the
PVCs
in
all
namespaces
like
this,
then
we
can
see
that
there
are
actually
two
PVCs
that
are
using
the
OCS
storage
class
and
that's
our
phosphorous
application
and
also
the
Nuba
database.
Nuba
database
is
using
50
gigabytes.
So
since
this
is
five
gigabytes,
this
is
indeed
our
ACEF
ammonium
that
were
exporting
to
our
application.
So
now
we
have
our
application
up
here
and
we
do
see
that
the
articles
are
there
and
everything
is
good.