►
From YouTube: Low ops Kubernetes storage with MicroK8s and OpenEBS
Description
No description was provided for this meeting.
If this is YOUR meeting, an easy way to fix this is to add a description to your video, wherever mtngs.io found it (probably YouTube).
A
A
Today,
we're
going
to
talk
to
you
about
low
ops,
kubernetes
storage
with
microcase
and
open
evs.
Let's
have
a
look
at
our
agenda.
For
today
we
will
start
with
a
problem
statement:
the
challenges
of
storage
in
kubernetes.
We
will
then
introduce
open
ebs,
the
popular
cncf
project
for
storage
and
its
latest
backend
called
maya
store.
A
A
B
Well,
because
kubernetes
is
effectively
the
posix
of
distributed
systems.
That
means
that
it
has
the
same
kind
of
constraints
as
you'd
have
in
a
traditional
infrastructure
setup,
where
you're
trying
to
replicate
data
across
physical
locations,
you're
trying
to
make
sure
that
data
is
kept
up
to
date,
and
you
have
a
way
to
back
that
data
up.
B
So
fundamentally,
the
the
problems
with
kubernetes
storage
are
the
same
as
storage
on
many
other
types
of
architecture,
but
on
top
of
that,
the
abstractions
are
very
complicated
because
you're
often
having
to
deal
with
the
idea
that
you're
working
with
primitives
that
don't
necessarily
map
to
the
kubernetes
landscape
directly.
So
what
I
mean
by
that
is
whether
you
have
a
nas
or
a
san
diego
file
systems
and
all
these
other
considerations
when
you're
thinking
about
your
storage,
not
to
mention
this
type
of
storage,
such
as
block
storage
versus
object
storage.
B
So
in
these
three
bullet
points,
I
think
that
effectively
summarizes
what
I
was
saying
with
the
the
last
part
being
that,
whilst
all
this
is
going
on,
you
need
to
make
sure
that
you're
not
having
any
sort
of
data
loss
and
integrity
is
kept
overall.
So
it's
a
really
tricky
thing
to
get
right
and
we've
seen
a
bunch
of
different
vendors
and
different
open
source
projects.
B
Attempt
to
cover
this
and
really
the
the
star
of
of
this
talk
is
maya
store,
which
is
a
driver
that
was
released
by
open
evs
just
gone
into
ga.
Quite
recently,
open
ebs
aren't
new
to
developing
kubernetes-based
storage
systems,
they've
actually
developed
c-store
amongst
one
of
their
other
drivers
and
have
been
doing
this
for
a
while.
B
What's
particularly
interesting,
though,
about
my
store,
is
that
not
only
is
it
built
on
pure
kubernetes
primitives,
it
has
a
control
plane,
a
data
plane
in
case
with
the
associated
custom
resources,
but
it's
also
boasting
a
bunch
of
key
features
that
are
pretty
exciting,
so
you've
got
the
ability
to
deploy
anywhere.
What
does
that
mean?
Well,
it's
not
tied
into
any
cloud
in
particular
as
long
as
your
underlying
host
is
relatively
commodity
based.
B
A
Microgates
is
a
cncf
certified
kubernetes
distribution.
Microkey
stands
out
for
its
ease
of
use
and
low
ops
approach
to
kubernetes
deployments.
All
kubernetes
services
are
packaged
in
a
single
artifact
called
a
snap,
and
it
only
takes
one
command
to
install
it
under
a
minute.
Microkeys
can
be
used
as
a
single
node
kubernetes
on
a
developer,
workstation
or
as
a
highly
available
cluster
for
production
in
clouds
or
the
iot
edge
on
workstations.
A
A
This
last
thing
is
possible
as
microcase
releases
a
week
after
upstream
and
all
the
latest
updates
are
made
available
immediately
using
microcase
as
a
local
kubernetes
allows
for
a
seamless
transition
from
development
to
staging
and
production,
as
you
can
use
the
same.
Conformant
kubernetes
deployed
in
all
stages
for
devops
features
such
as
self-healing
high
availability,
transactional,
over-the-air
updates
and
security.
Patches
and
sandbox
cubelet
environments
make
microkeys
the
go-to
platform
for
mission-critical
workloads.
A
You
can
also
quickly
spin
up
nodes
up
or
down
as
part
of
your
standard
ci
cd
pipeline.
Another
big
benefit
for
platform
teams
is
lower
cluster
maintenance
costs,
as
with
microkeys.
Many
of
the
cluster
operations,
such
as
data
store,
maintenance
and
upgrades,
are
automated
or
simplified
to
just
a
few
commands
respectively
and
for
software
vendors
working
on
container
solutions,
microkey's,
simplicity,
robustness
and
security
make
it
a
great
kubernetes
platform
to
embed
into
their
cloud-native
solution.
A
A
A
single
command
gets
you
bootstrapped
with
kubernetes
networking,
storage,
observability,
gpu
acceleration,
serverless
frameworks
and
so
on,
just
one
command
to
turn
these
on
or
off,
and
by
the
way
you
can
also
create
your
own
add-ons
using
the
add-on
framework.
One
of
the
latest
microcase
add-ons
is
open
ebs.
The
open
ebs
add-on
was
originally
contributed
by
one
of
our
community
members
in
2021
and
was
delivered
as
part
of
microgate's
release.
A
So
now
let
me
present
you
a
bit
of
the
microgates
architecture
and
show
you
how
the
open
ebs
add-on
works.
On
top
of
microgates,
like
I
said
before,
microkeys
is
delivered
as
a
snap,
which
is
really
a
squashfest
file
system
that
runs
all
the
kubernetes
services
in
a
sandbox.
Therefore,
shielding
the
underlying
system,
the
snap
packaging,
also
unlocks
automatic
updates
and
uses
semantic
channels
to
easily
handle
upgrades.
A
What's
really
great
about
the
mystore
add-on.
Is
that
when
you
cluster
individual
microkeys
nodes
that
have
the
add-on
already
enabled
together,
the
maestro
control
plane
will
also
become
distributed
across
the
nodes.
Alongside
the
kubernetes
control
plane,
no
additional
commands
or
configuration
needed.
A
local
file
is
being
used
inside
the
snap.
So
you
don't
need
an
attached
drive
to
enable
this,
and
this
is
how
we
enable
distributed
block
storage
with
maya
store
from
single
to
multi-node
clusters.
B
B
B
After
this,
it
will
install
the
helm
chart
and
bring
up
the
additional
services
that
are
required.
This
is
a
batteries
included
installation,
so
we
do
quite
a
few
things
under
the
hood
beyond
just
installing
the
helm
chart
such
as
provisioning
the
storage
connecting
up
the
storage
pools
and
making
sure
that
you're
able
to
create
volumes.
B
So
let's
talk
about
how
that
works
just
after
we've
validated
that
things
are
starting
up,
so
this
looks
good
we've
got,
coordinates,
started
and
the
next
few
seconds
we'll
see
my
store
enabled
so.
Looking
at
this
illustration
here,
you
can
see
that
we
have
three
nodes
in
this
example.
If
we
pick
one
of
these
nodes,
just
like
the
one
we're
looking
at
today,
my
store
has
its
storage
inside
of
sparse
image
file
that
we
create
for
you
inside
the
snap.
B
This
is
intentional
because
it
doesn't
rely
on
any
external
volumes,
any
external
disks
or
setup
to
be
required.
We
have
it
all
in
this
self-contained
snap,
which
is
really
nice,
because
when
you
delete
the
snap
you
can
get
rid
of
the
block
storage,
if
you
so
wish
to.
It
also
means
as
well
that
we
can
set
with
a
known
set
of
defaults,
and
that
means
that
we
can
start
to
build
out
a
cluster
in
a
very
predictable
way.
B
Just
in
the
background,
let's
check
we
can
see
now
that
my
store
is
coming
up
online.
My
store
is
comprised
of
two
primary
category
of
components.
You
have
the
control
plane,
which
is
known
as
moac,
and
then
you
have
the
data
plane,
which
is
comprised
of
the
csi
controller
and
the
nexus
pod.
The
csi
controller
does
all
the
typical
handling
functions
such
as
attach
detach,
publish
and
publish,
and
then
the
nexus
part
is
what
controls
replication
and
actually
writes
as
a
proxy
to
other
pods.
B
With
that
said,
those
are
primarily
illustrated
here
in
this
teal
color,
where
the
nexus
pods
are
effectively
the
most
important
parts
of
the
maya
store
components.
However,
you
need
all
of
them
to
make
it
work.
What's
really
cool
about.
This
is
that
when
you
scale
up
a
micro
case,
cluster
with
maya
store,
enabled
you
automatically
get
new
block
storage
available
and
that
will
get
recognized
by
my
store
and
it
will
start
replicating
where
required.
B
On
top
of
this
illustration,
you
can
see
that
we
have
this
object
called
mystore.
These
are
custom
resources.
The
reason
these
exist
is
that
these
are
to
help
us
to
effectively
manage
the
local
node
and
that
local
node.
We
want
to
be
able
to
tell
it
which
disks
to
connect
to
now,
because
we're
providing
this
as
a
batteries
included
solution.
We
know
where
these
block
storage
files
live,
so
we
write
that
into
the
custom
resource,
but
what's
cool
is
that
you
can
also
extend
this.
My
store
pool
to
add
some
attached
optional
disks
later
on.
B
B
So
let's
go
back
and
see
how
we're
getting
on
the
initializing
pods.
Here
you
can
see.
We
have
now
the
my
store
nexus
pod,
which
is
just
coming
up
online,
and
we
also
have
the
csi
controller.
That's
finishing
off
it's
worth
noting.
If
you
look
at
our
custom
resource
definitions
that
we
have
also
our
maya
store,
pools,
type
which
has
been
installed,
and
we
have
the
pool
of
foo,
which
is
the
name
of
my
node,
which
has
just
come
up
online.
B
B
B
B
B
And
then
I've
got
a
pod
that
is
going
to
attach
to
that
pvc
just
for
good
measure.
So
we
look
inside
our
cluster.
You
can
see
we
already
have
container
creating
we
go
to
our
pvcs.
You
can
see
that
that
pvc
is
bound
to
the
storage
class
of
my
store,
and
now
you
can
go
to
volume
attachments
and
see
that
the
attacher
is
set
to
the
csi
maya
store.
Let's
take
this
pvp
uid.
B
B
There
we
go,
we
can
see
that
the
task
pv
pod
is
running
with
this
persistent
volume
claim.
In
the
background,
of
course,
this
is
only
the
beginning.
What's
also
really
exciting
is,
as
you
start
to
scale
out
this
cluster,
you
can
start
to
see
my
store
and
its
replication
and
all
the
powers
that
go
with
that.
This
is
just
the
first
step
on
what
will
help
to
give
you
storage
without
even
having
to
think
about
it.
So,
as
I
go
back
to
my
my
store
pool,
I
may
well
want
to
add
additional
disks.
B
I
may
want
to
make
adjustments.
It
supports
a
bunch
of
formats,
so
you've
got
async
disks.
You've
got
ram
disks,
you've
even
got
in-memory
disks
as
well.
So
there's
a
bunch
of
stuff.
You
can
do
that's
really
cool
here,
especially
for
performance
testing,
quickly,
fuzzy
testing
as
well,
which
is
really
nice.
B
B
So
just
as
a
recap
from
the
demo
there
I'll
show
the
illustration
again
and
just
as
a
reminder,
my
store
is
being
used
inside
of
microcase
and
in
the
conjunction
with
the
sandboxed
environment
of
microcase.
It
means
that
anybody
can
deploy
out
distributed
storage
on
top
of
microcase
in
a
very
simple
way.
What's
also
really
cool
here.
Is
that,
of
course,
as
I
mentioned,
and
showed
you,
the
getup
and
get
going
part
is
super
simple,
but
then
adding
more
nodes
into
the
cluster
is
equally
very
straightforward,
and
then
you
have
built-in
resilience
and
replication.
A
That
was
a
truly
awesome
demo
alex
thank
you,
and
that
also
concludes
our
error
time
for
today.
Thank
you
very
much
for
watching.
We
invite
you
to
try
out
the
new
microcase,
open,
ebs
add-on
using
the
commands
you
see
now
on
your
screen.
We
of
course
look
forward
for
your
feedback,
so
feel
free
to
reach
out
to
us
on
slack
github
or
our
social
media
channels,
and
you
can
always
check
out
our
website
for
more
information
about
microgates
and
canonical
kubernetes.
B
Thank
you
again,
everyone
I
really
enjoyed
demoing
and
being
here
with
alex.
It's
been
a
real,
exciting
opportunity
for
us
to
talk
about
some
of
the
latest
innovations
in
microkates.
We
really
like
the
fact
that
we're
marrying
together
with
a
cncf
project,
and
especially
one
that's
bringing
such
awesome
features
as
my
store
thanks
very
much.