►
Description
By the end of this talk users will know how Kubernetes Operators can improve their experience with deploying large-scale applications in their clusters. Attendees will also learn how IPFS Cluster leverages the Operator SDK in order to easily perform horizontal scaling of Web3 storage.
A
A
So
in
this
talk
you
will
learn
about
how
to
use
kubernetes
you'll,
learn
about
how
ipfs
cluster
uses
kubernetes
and,
more
importantly,
you're,
going
to
walk
away,
knowing
how
you
can
make
kubernetes
work
for
you,
instead
of
against
you.
So
a
brief
background.
This
is
all
about
containerization.
If
you
don't
know
what
containers
is.
A
I
have
a
a
neat
graphic.
So
this
is
the
world
before
containers
and
it
was
not
good
we're
not
going
to
get
into
that,
but
it
was
not
good.
So
what
containers
are?
Is
it's
virtualized
software
and
basically,
when
you
take
some
like
package
by
some
binary,
you
package
it
with
the
software
that
it
needs
and
then
you
basically
compile
it
into
container
image
and
then
these
go
out
and
then
people
just
download
them
from
anywhere
and
are
then
able
to
run
that
software
without
needing
to
actually
have
the
dependencies
on
their
system.
A
For
example,
if
we
have
the
Kubo
binary,
we
can
take
that
dockerize
it,
and
that
is
essentially
what
you
run
when
you
pull
from
Docker
IO
ipfs,
slash,
Kubo
latest
and
it
like
lives
in
its
own
sphere.
Basically,
so
we
can
pass
it
environment
variables
like
ipfs,
swarm
key.
You
can
set
an
expose,
API
ports
like
it
exposes
the
API
Port,
the
Swarm
pillar
on
4001,
and
you
can
mount
different
volumes
and
be
able
to
actually
like
plug
storage
in
and
out.
It's
really
neat.
A
So
one
of
the
main
reasons
why
Docker
is
so
great
is
that
you
could
just
use
it
at
the
command
line.
So
if
you
want
to
run
like
go
ipfs
or
Kubo
today,
you
can
do
Docker
run
ipfs
go
ipf.
Well,
today
it's
Kubo
and
it'll
just
run.
It
starts
the
entire
binary
without
Blake
worrying
about
how
your
system
is
configured,
you
can
have
the
messiest
system
in
the
world
and
this
will
still
run
provided
you
have
Docker
installed,
of
course,
so
they're
really
helpful.
A
When
you
have
one
container,
you
can
set
the
environment
variables
as
you
want.
If
you
have
two
containers,
yeah
they're
really
helpful
three
again,
we
can
just
keep
adding
them,
but
things
start
to
get
shaky,
so
they
have
their
limitations
that,
as
you
scale
them
up,
because
you're
just
running
commands.
A
If
you
want
to
make
adjustments
to
it,
that's
going
to
cost
you
a
bit
of
time.
Everything
has
to
be
done
manually
and
existing
Solutions
like
Docker
swarm
are
just
not
that
great
to
use,
because
you
need
more
fine-grained
like
orchestration.
You
need
resources
to
be
available
at
time
of
launching.
So
if
you
wanted
to
do
something
like
you
want
to
take
a
subset
of
your
containers
and
you
wanted
to
apply
a
label
to
them
and
then
based
off
that
label,
you
want
to
apply
some
ipfs
profile.
A
Well,
you
could
do
that
with
the
docker
CLI,
but
it's
just
going
to
take
more
bash
scripting
and
a
lot
of
work
on
your
end,
and
we
don't
want
that.
We
want
you
to
focus
on
the
code,
so
you
can
just
do
your
job,
so
they
start
to
become
unproductive
as
you
get
more
and
more
containers
like
at
this
point.
This
is
just
crazy
and
then
this
is
ridiculous.
This
is
container
overload.
We
don't
want
this.
This
is
bad,
so
here's
a
quiz.
A
I'm
not
seeing
any
hands
so
at
some
point,
when
you're
using
containers,
your
workflow
of
trying
to
adjust
some
API
Port
is
going
to
start.
Looking
like
this,
you
don't
want
to
be
doing
this.
You
want
to
be
writing
code,
so
the
solution
is
to
use
actually
kubernetes.
It
might
seem
counter-intuitive
because
everyone
talks
about
how
it's
so
hard,
but
there
are
a
lot
of
things
you
can
do
to
make
kubernetes
actually
work
for
you
and
we're
going
to
show
you
how
to
do
that.
A
So
to
first
start
out,
we
have
to
say
what
is
kubernetes,
it's
a
container
organization,
orchestration
platform
and
what
that
means
is
at
its
core.
It
allows
you
to
like
Define
how
you
orchestrate
all
your
different
containers-
and
it
does
this
through
a
process
called
eventual
consistency
where
you
define
what
you
want,
and
it
eventually
gets
to
that
point
and
if
there's
a
problem,
it
tries
to
self-heal
or
basically
die
doing
so
it's
made
up
of
a
few
nodes,
there's
the
control
point
and
there's
worker
nodes,
the
control
plane.
A
Just
it's
like
the
Futurama
brain,
oh
I,
think
I
deleted
it.
We
don't
need
to
get
into
that,
but
basically
it
stores
the
state
and
then
it
tries
to
get
everything
to
that
state
or
to
your
desired
State
and
to
interact
you
just
contact
its
API,
it's
very
like
self-explanatory,
at
least
when
you
start
working
with
it,
and
it
makes
your
life
a
lot
easier.
So
when
we
talk
about
atomicity,
it's
commonly
known
that
there's
the
four
major
elements
of
nature.
We
have
wind
fire,
water
and
Earth.
A
Well,
in
software
we
have
the
same
thing.
We
have
the
four
elements
of
software
engineering.
We
have
your
application
layer,
we
have
your
storage
layer,
your
networking
later
and
your
configuration
later
and
most
of
the
time.
These
are
the
four
main
things
that
you're
going
to
be
working
with
when
you're
building
those
precious
apps.
A
So
in
kubernetes
there
are
Atomic
resources
for
these
things.
There
are
other
resources
Beyond
this,
but
they're,
usually
just
an
extension
of
these
four
that
do
more
specific
things.
Your
first
one
is
the
pod.
That's
going
to
be
your
application
layer,
that's
going
to
actually
run
the
code.
Then
you
have
the
service
and
then
we
have
persistent
volume
claims
such
as
storage,
and
then
you
have
the
configuration
layer
so
pods.
These
are
basically
like
Apartments.
They
provide
a
common
space
for
containers
to
exist
and
people
within
their
Apartments
like
they
do
their
things.
A
They
don't
know
about
the
people
in
the
other
apartments,
but
they
still
share
the
same
water.
They
still
share
the
same
electricity
and
pods
provide
this
type
of
infrastructure,
and
that's
going
to
be
where
your
application
runs.
Then
you
have
the
service.
This
is
like.
When
you
have
a
telephone
operator,
they
connect
different
Services
together
and
provide
a
way
for
them
to
be
accessed.
So
this
is
your
networking
layer.
There's
different
types:
there's
cluster
IP,
there's
node
Port
load
balancer
we're
not
going
to
get
into
this
today,
but
they
exist.
A
There's
the
storage
layer,
your
persistent
volumes,
these
simply
claim
pieces
of
storage
there's
different
modes.
You
can
use
a
lot
of
different
things
that
you
can
do
with
these,
and
then
you
have
your
configuration
layer,
config
map,
Secrets
whatever
this
is
where
you
actually
store,
like
your
passwords,
your
scripts,
things
that
your
application
will
need
in
order
to
run.
But
it's
not
exactly
storage
in
the
same
sense
of
like
generating
application
data.
A
So
this
is
just
the
vs
code
extension
it
generates
the
like
base.
Blower
play
it's
not
very
complicated,
but
we're
just
going
to
name
this
ipfs
and
we're
going
to
apply
the
ipfs
label
and
down
here
is
where
we
actually
specify
which
container
we're
pulling
here,
we're
going
to
do
the
docker.io,
slash,
ipfs,
slash,
Kubo,
latest
image
and
then
for
our
resource
usage.
This
is
like
we
can
set
limits.
This
is
a
default
one,
but
it'll
work
fine,
and
then
we
can
expose
ports.
A
So
we
expose
that
and
now
we
can
apply
this
directly
in
our
cluster,
but
this
is
not
going
to
be
accessible
from
the
outside
world.
So
what
we
have
to
do
is
we
have
to
create
a
service
to
actually
access
it.
So
we'll
do
that
we'll
create
this
separator
and
we'll
say:
create
a
service
and
again
I'm
going
to
do
that.
Boilerplate,
because
it's
helpful
and
this
is
going
to
be
called
ipfs
service
and
then
the
selector
we're
going
to
do
name
ipfs
and
then
here
we're
going
to
expose
Port
4001.
A
So
in
order
to
we
don't
need
to
do
anything
else
to
actually
use
that
it's
just
automatically
going
to
do
that.
The
next
thing
that
we'll
need
is
storage.
So
the
way
that
we
do
this
is
we
first
want
to
create
a
PVC.
So
we'll
do
that
we'll
say
persistent
volume
claim.
This
is
just
going
to
be
called
ipfs
data
and
then
we're
going
to
like
say:
I,
don't
know
how
much
storage
do
we
want.
Somebody
shout
a
number
out.
A
Five
gigs
five
bibs,
okay,
five
bi
I,
don't
I,
don't
think
that's
gonna
work,
but
we're
gonna
keep
that
and
then
what
we
do
in
order
to
actually
use
that
storage
is
we
go
into
our
spec
and
we
simply
say
volumes
and
we
specify
the
volume
that
we
want
to,
or
we
give
it
a
name.
So
this
is
going
to
be
called
ipfs
storage
and
the
name
here
is
important,
because
this
is
actually
what
the
container
is
going
to
use
as
a
reference.
A
It's
like
a
variable
basically
and
then
we're
going
to
specify
that
we
want
to
pull
a
persistent
volume
claim
and
the
claim
name
is
going
to
be
ipfs
data
and
then
to
use
this
in
our
container.
All
we
need
to
do
is
we
go
to
volumes,
volume
mounts
I,
think,
and
this
is
just
going
to
be
another
list,
so
we
need
to
reference
the
name.
So
this
is
going
to
be
the
claim
the
this
is
going
to
be.
What
did
we
call
it?
A
I
think
that
should
be
good
okay,
so
we
set
the
mount
path
to
be
slash:
data,
slash,
ipfs,
and
now
our
container
is
going
to
be
mounting
this
PBC
at
that
path,
and
the
last
thing
we'll
need
to
do
is
actually
set.
So
I
want
this
to
be
private,
so
we'll
pull
in
an
environment,
variable
and
I'll
show
that
all
we
need
to
do.
Is
we
go
to
our
container?
We
specify
the
ends.
Is
it
n
or
ends
it's
n
and
then
the
name?
A
A
A
A
Okay?
Well
now,
let
me
show
you
what
we
do
for
ipfs
cluster,
because
this
is
going
to
be
really
simple.
So
first
you
want
to
create
your
relay
circuit
identity
right
then
you
want
to
create
your
relay
circuit
config,
and
then
you
want
to
create
your
relay
circuit
and
of
course
we
need
another
service
to
expose
it.
Then
we
actually
need
an
ipfs
config.
Then
we
need
our
ipfs
secret
Keys.
Then
we
can't,
for
we
can't
forget
storage.
A
We
need
that
and
of
course,
the
ipfs
cluster
that
needs
storage
too,
and
then,
of
course,
we
need
to
deploy
ipfs
and
then,
of
course,
we
need
a
way
to
access
it,
so
that
that
simple
right,
everyone
find
that
easy.
You
guys
are
all
kubernetes
Masters.
Now
you
can
go
and
do
that
tomorrow,
right,
yeah,
I,
didn't
think
so
either,
because
I
certainly
have
to
spend
a
lot
of
time.
Googling
this
stuff
and
I.
Don't
want
to
be
doing
that
and
I
don't
want
anyone
else
to
think
that
that's
how
you
should
be
using
kubernetes.
A
A
Now
operators
are
great
because
they
operate
everything
for
you,
so
they
expose
very
simple
interfaces
for
these
very
complex
things
that
I
just
showed
you
and
they
operate
on
your
behalf
and
they
either
try
and
succeed
or
they
fail,
and
they
tell
you
why
and
they
give
a
good
reason
for
it,
provided
that
the
reason
is
easy
to
access
Asterix,
most
of
the
time,
they're
very
easy
to
use.
So
our
yaml's
before
operators
look
like
this
right.
That's
what
I
just
showed
you
before.
After
that.
They
look
like
this.
A
This
is
what
you
want
to
be
using
so
to
do
ipfs
cluster
in
kubernetes.
First,
you
want
to
install
this
thing
called
operator,
lifecycle
manager,
and
this
is
kind
of
like
on
your
phone.
You
have
the
App
Store
and
you
can
just
simply
press
install
on
an
app
and
it
installs
on
your
phone.
So
in
kubernetes
we
have
the
same
thing
through
oom.
Then
you
actually
go
and
install
the
opiofs
operator,
and
you
may
wonder
how
I
got
this
link
right,
because
this
is
not
easy
to
guess.
A
Well,
there's
this
handy
dandy
website
called
operator
Hub,
and
this
is
essentially
your
app
store
for
your
kubernetes
operators.
All
of
your
glorious
things
that
you
want
to
be
using
all
of
your
finest
software,
your
grafana
dashboards,
your
Apache
Kafka,
your
everything
you
can
find
here
and
if
you
can't
find
it
because
you
have
something
custom,
you
can
create
them,
they're
pretty
easy
to
make
and
in
order
to
use
ipfs
cluster
in
kubernetes,
you
simply
search
for
ipfs.
You
click
on
that
button.
A
You
click
that
that
glorious
blue
install
button-
and
it
tells
you
the
three
steps
right
there
for
you
to
install
it's
that
easy
and
then,
finally,
when
you
actually
go
and
create
it,
all
you
need
to
do
is
just
install
that
thing
or
run
it,
and
it
might
be
a
bit
small,
so
I'm
going
to
show
you
how
it
looks
and
we
can
go
through
each
of
the
options
step
by
step,
because
it's
really
quite
simple
so
right
at
the
top.
We
have
the
kind
of
ipfs.
This
has
been
changed
to
be
kind
ipfs
cluster.
A
It
doesn't
really
matter,
you
give
it
your
name,
you
name
your
cluster,
you
tell
it
how
much
ipfs
storage
it
should
be
using
you
tell
it
how
much
cluster
storage
it
should
be
using
you
tell
it
how
many
replicas
you
want.
You
tell
it
how
much
circuit
relays
you
want.
You
tell
it
which
clusters
to
follow
if
any
all
of
these
options
are
just
right
here
in
one
convenient
file,
and
then
you
just
go
and
launch
that
and
I'll
show
you
what
that
does.
A
A
A
If
you
want
to
start
using
operators
and
Cube
Today,
you
can
go
to
operator
hub.io,
you
can
create
your
own
if
one
doesn't
exist
through
operator
SDK
and
then,
of
course,
we
have
our
glorious
ipfs
operator,
which
you
can
download
and
I
recommend
you
download
it
through
operator
hub.io
and
then,
of
course,
we
have
our
source.
So
if
anyone's
interested
in
furthering
this
project
in
helping
us
get
an
even
better
operator,
go
to
that
link
contribute,
we
will
love
your
help,
so
I
really
do
hope
that
people
walk
away.