►
From YouTube: Into the Powergate - Andrew Hill & Aaron Sutula
Description
The Powergate is an API driven solution for deploying multitiered storage across Filecoin and IPFS. Persistent storage on Filecoin allows rich storage configuration for data such as replication factor, miner selection, deal renewal, and repair. Network available storage is configurable and provided through a connected IPFS peer or pinning network.
Read more about the inaugural IPFS Pinning Summit on the website: https://ipfspinningsummit.com/
For more information on IPFS
- visit the project website: https://ipfs.io
- or follow IPFS on Twitter: https://twitter.com/IPFS
Sign up to get IPFS news, including releases, ecosystem updates, and community announcements in your inbox, each Tuesday: http://eepurl.com/gL2Pi5
For more information on Filecoin
- visit the project website: https://filecoin.io
- or follow Filecoin on Twitter: https://twitter.com/Filecoin
Get Filecoin community news and announcements in your inbox, monthly: http://eepurl.com/gbfn1n
A
My
name
is
Andrew
I
work
at
textile
and
I'm
going
to
talk
to
you
about
a
technology.
That's
come
up
a
couple
times
called
the
power
gate
just
a
little
bit
about
textile,
so
we're
a
small
team
of
five
people.
Myself
and
Aaron
are
going
to
present
to
you
today,
but
I
wanted
to
make
sure
to
give
a
shout
out
to
the
other.
A
The
other
team
members,
especially
Ignacio
who's,
really
let
a
lot
of
the
work
on
the
power
gate
with
us
as
support
and
and
so
just
want
to
make
sure
that
I
gave
him
a
shout
out,
but
you
can
find
all
our
work
on
on
github
as
well,
so
you
can
see
everything
there
and
how
people
are
contributing.
So
today's
talk
it,
so
you
want
to
plug
file
coin
into
your
architecture.
So
maybe
you
want
to
drop
it
into
an
existing
system
as
an
API
or
maybe
you
want
to
run
file
coin
in
a
stateful
way.
A
A
A
So,
for
example,
I
saw
the
question
from
Ruben
I
believe
about
locations
and
filtering
of
miners,
and
so
this
is
a
great
place
where
it
does
it.
So
the
power
gate
will
track
more
than
just
the
location
of
miners,
but
also
how
long
they've
been
on
the
network
and
what
kind
of
deals
they're
making,
and
so
you
can
actually
create
deals
based
on
filtering.
A
Going
forward,
but
you
can
configure
how
you
want
that
caching
work
to
work
so
that
you
can
say
I
want
data
on
the
network,
but
if
it
ever
drops
below
what
I
think
is
an
acceptable
threshold
of
availability
on
the
network
and
that's
measured
in
time
to
retrieve
it.
You
can
have
the
power
gate,
basically
rebuff
that
that
data
on
the
network,
so
that
it's
there
and
available
again
for
your
users
or
your
application,
and
this
is
this-
is
very,
very
exciting
for
sort
of
this
mixed
network
user.
A
A
You
can
run
a
very
simplified
and
fast
local
version
of
the
network,
so
that
you
can
see
how
the
API
is
work.
You
can
test
the
flow
of
data
and
in
the
future,
a
lot
of
this
will
be
much
more
bring
your
own
notes
and
so
that
that's
really
important
for
people
like
pinning
services.
That
probably
are
that
definitely
already
have
their
own
IP
FS
nodes
and
their
own
IP
FS
networks
and
we'll
be
thinking
through
ways
to
attach
file
coin
to
their
existing
IP
FS
api's.
A
A
That's
a
perfect
analogy
for
how
we've
been
thinking
about
the
multi-tiered
storage
being
deployed
using
the
power
gate
where
you
use
ipfs
as
your
hot
storage,
your
fast
layer
where
data
is
available
to
the
network
broadly
and
you
use
file
coin
for
persistence,
your
cold
storage,
making
sure
that
data
exists,
and
then
you
connect
it
through
some
automated
processes
that
you
can
actually
control
and
configure.
Right.
Now,
we've
focused
on
these
two
layers.
A
There's
a
lot
of
room
for
these
layers
to
expand
as
well
and
I'll
talk
a
little
bit
about
that
as
well
layers
layers
beyond
hot
and
layers
between
hot
and
cold,
and
so
keep
that
in
mind
as
well,
and
then
all
of
this
is
actually
wrapped
up
in
widely
supported,
G,
RPC
API
and
the
thing
that's
nice
about
that
API
approach
is:
it
makes
it
a
pretty
standard
way
to
attach
to
this
API
from
different
platforms
and
languages.
So
you
can
build
your
own
clients.
A
You
can
build
your
own
wrappers,
your
own
libraries
and
and
we'll
show
you
some
of
that,
and
so
one
example
of
an
application.
That's
attaching
to
that.
Api
is
our
CLI,
and
so,
when
you
run
the
binary
client
for
the
power
gate,
it's
really
built
for
the
system
administrator
or
the
power
user,
or
a
developer
I'm
coming
to
try
to
build
this
stuff
and
test
it
out,
but
that
CLI
is
actually
hitting
that
G
RPC
API,
and
it
will
make
this
all
feel
very
simple,
but
don't
be
fooled.
This
is
pretty.
A
A
So
the
the
surface
area
of
API
is
in
power.
Gate
is
pretty,
is
pretty
broad
and
expansive
and
it
actually
brings
a
lot
of
the
api's
that
are
already
available
in
Lotus
and
and
passes
them
through,
and
that
makes
them
available
to
you.
But
one
thing:
sort
of
like
the
the
area.
That's
going
to
be
of
most
interest,
I
think
to
people
trying
to
deploy
this
in
systems
is
an
area
called
the
ffs.
A
The
ffs
is
the
it's
short
for
the
file
coin
file
coin
file
system,
and-
and
this
is
a
really
important
piece
of
the
power
gate
sort
of
stack,
so
the
file
coin
file
system,
every
each
power
gate
can
have
one
to
many
file
coin
FF
asses
and
every
F
of
s
has
an
address.
It
can
actually
manage
multiple
addresses,
and
this
is
where
the
sandbox
thing
happens.
A
So
if
say,
you
wanted
to
run
the
power
gate
behind
an
application
that
you
wanted
to
give
every
user
an
address
on
file
coins
so
that
they
could
manage
their
own
configuration
for
how
storage
is
happening.
They
could
have
their
own
account
balances.
You
could
actually
just
create
them
an
ffs,
and
so
every
ffs
is
going
to
have
its
own
address.
It's
going
to
have
its
own
configurations
to
manage,
and
it's
going
to
have
its
own
set
of
deals
on
net
on
the
network
and
also
it's
going
to
have
its
own
set
of
data.
A
So
I
mentioned
that
the
FS
has
a
configuration
for
how
it's
doing
deals
and
we're
going
to
talk
more
about
the
configuration
itself,
but
the
that's
just
the
default
configuration
and
if
you
create,
if
you,
if
you
store
new
data
in
the
power
gate,
you
can
actually
override
the
default
configuration
and
have
a
different
configuration
for
every
files.
Keep
that
in
mind,
as
I
sort
of
show
you
this
going
forward,
that
every
storage,
every
file
storage
request
that
you
make
to
the
power
gate.
A
You
can
send
it
your
new
configuration
and
actually
you
can
override
those
configurations.
So
let's
talk
about
what
it,
what
I
mean
by
config
I
said
this
a
bunch
of
times.
So
I
already
mentioned
that
we
break
this
up
into
the
hot
storage
in
the
cold
storage.
We
can
look
right
here
at
the
config
itself
and
look
at
what's
happening
in
the
config.
That's
controlling!
What's
going
to
happen
in
the
in
the
two
layers
of
storage.
So
in
this
case
this
is
the
fault
storage
config,
for
my
ffs,
like
I,
said.
A
I
could
override
this
for
any
new
file
that
I
want
to
store
with
the
power
gate,
but
by
default
you
can
see
a
few
things
one.
It's
saying
that
I
want
this
data
to
just
be
available
on
the
hot
network
and
then
I'm
gonna
actually
skip
in
the
next
two
because
they're
important,
but
let
me
jump
right
down
to
the
cold
storage,
so
cold
storage.
These
are
all
the
controlling
configurations
for
the
file
coin
storage,
and
so
you
can
see
things
like
replication
factor.
The
default
is
one
deal
duration.
It
has
a
default.
A
A
I
actually
am
gonna
wait,
some
time
to
see
if
I
can
get
it
from
the
network,
and
in
this
case
the
default
is
to
wait
for
30
seconds,
and
so
in
that
way
you
can
actually
let
the
network
provide
you
data
at
this
hot
hot
layer
before
you
go
back
to
file
coin,
to
create
a
new
retrieval
deal,
and
this
is
where
these
really
interesting.
Network
configurations
come
up
and
that's
where
this
allow
unfreeze
configuration
comes
in
so
allow
unfreeze
means
it's.
If
you
only
have
it
in
the
coat
layer.
A
A
So
I
already
talked
about
the
add
timeout,
but
that's
this
is
a
really
interesting
property,
and
is
it
really.
These
are
really
like
is
a
perfect
example
of
a
place
that
we
think
is
really
important
and
that
we
want
to
build
out,
and
so
we'd
love
your
feedback
on
these
things
and
how
you're
imagining
building
it
in
your
system.
A
As
you
start
looking
at
this
and
trying
to
build
with
it.
Are
there
other
other
layers
of
configuration
that
would
be
helpful
to
standardize
here
so,
what's
hotter
than
hot,
and
this
would
be
thinking
about
perhaps
you're
running
a
pending
service
where
you
have
globally
distributed
nodes,
and
you
want
to
be
able
to
smart
intelligently,
configure
how
this
data
gets
pushed
out
to
those
different
nodes
and
maybe
there's
layers
in
between
as
well.
One
other
really
interesting
thing
that
we
haven't
spent
much
time
developing,
but
I.
Think
it's
it's
available
in
here
and
worth
exploring.
A
Is
that
in
the
early
I'll
coin,
the
power
gate
might
actually
be
able
to
help
serve
things
like
locally
available
data.
So
by
knowing
which
data
is
stored
in
the
by
the
power
gate.
You
can
take
deals
to
retrieve
that
data
and
pass
those
deals
off
to
two
nodes
in
other
regions.
So
they
can
actually
do
the
retrieval
locally
to
the
user,
requesting
the
data
get
it
into
local
ipfs
nodes,
but
only
only
have
to
run
one
one
power
day
in
your
system
and
that's
the
sort
of
configuration.
A
That
is
just
it's
just
on
our
mind,
but
we'd
love
to
know
how
you're
imagining
deploying
this
stuff
so
that
we
can
get
that
just
right.
So
hopefully
that's
enough
kind
of
early
information
to
get
you
really
interested
to
see
how
this
thing
works
and
think
about
dropping
it
into
your
applications,
and
so
with
that
I'm
going
to
pass
this
over
to
Aaron
to
give
a
little
demo.
But
so.
B
Yeah
I'm
Aaron
I've
been
working
on
power
gate
with
Ignacio
quite
a
bit.
Recently,
it's
been
really
really
fun
and
exciting
project
and
I'm
excited
to
show
you
guys
what
we've
been
working
on
with
this
demo
today.
So
first
thing
I'm
gonna
do
is
like
Andrew
was
talking
about
all
of
the
it's
kind
of
getting
up
and
running
can
be
easily
done
with
our
docker
images
that
come
in
our
repo,
so
I'm
gonna
go
ahead
and
start
up
embedded
test
net.
B
It's
just
running
locally
on
my
computer
with
one
miner,
so
we
can
run
the
CLI
against
it.
I'm
gonna
filter
out
a
bunch
of
extra
lotus
logs,
and
just
so,
we
can
just
see
the
power
gate
logs
that
are
are
happening
happening
here
so
that
you
start
it
up
and
then
over
on
the
left,
hand,
side
and
we'll
start
using
the
CLI.
That's
just
simply
called
POW.
B
You
can
see
here
from
the
documentation.
There's
a
lot
going
on
a
lot
of
the
the
commands
here.
You
can
you're
free
to
use
them,
but
the
main
one
like
Andrew
was
saying
is
ffs.
In
fact,
the
logic
within
the
ffs
command
is
really
using
like
a
lot
of
the
other
modules
that
are
exposed
here.
But
to
give
you
an
example
like
of
some
of
them
like
if
I
say,
palnet,
piers
I'll
get
a
list
of
piers
on
the
network
and,
of
course,
since
we're
just
running
the
local
dev
net.
B
Yeah
and
there's
other
commands
available
to
query
file
coin
asks
and
current
deals
and
the
health
of
the
node
and
miners
on
the
network.
We
build
some
indexes
that
are
that
don't
exist
necessarily
like
within
the
file
coin,
blockchain
or
anything,
but
we're
indexing
data
and
building
reputation,
index
slashing
index
and
the
index
of
miners,
where
we
add
metadata
like
miner,
location
and
other
things,
but
yeah.
B
I
saw
a
question
earlier
about
whether
or
not
this
thing
is
a
JWT
I.
Think
today
it's
not
it's
just
some
generic
token,
but
we're
actually
in
the
process
right
now
of
adding
different
authorization
levels
for
clients.
So
there
can
be
like
some
commands
that
are
only
available
to
like
admins
and
others
that
are
only
available
to
other
users,
so
I'm
guessing
with
that
change,
we'll
have
to
use
something
like
Jada
cuties.
B
Okay,
so
back
to
the
documentation
here,
just
to
do
a
quick
example
of
one
of
the
other
commands:
let's
create
a
new
address
using
the
adders
sub
command
here,
so
if
I
say
pow,
ffff,
Heather's,
new
and
I
give
it
a
name.
My
address
okay.
So
now
we've
created
a
new
wallet
address
that
is
owned
by
my
ffs
instance
in
and
secured
with
that
auth
token
that's
associated
with
my
ffs
instance.
B
B
But
okay,
let's
skip
to
actually
storing
storing
data
in
this
directory
and
I
just
had
this
little
index.html
file
and
we're
going
to
store
this
thing
in
file
coin
and
then
we're
going
to
pull
it
down
from
file
coin
onto
the
ipfs
network,
just
see
how
this
all
works.
So
this
is
HTML
file
here
locally
on
my
computer,
then
we'll
go
back
here
and
like
Andrew
was
talking
about
storage
in
power.
Gate
is
all
managed
by
configuration.
B
So
if
I
want
to
view
the
default
configuration,
the
all
data
will
be
stored
with
if
I
don't
provide
an
override
I
can
type
ffs
config
default
and
that's
going
to
print
our
default
storage.
Configuration
similar
to
the
one-hander
was
showing
where
hot
and
cold
storage
are
enabled
by
default
with
some
sensible
default
settings.
B
B
B
So
first
thing
I'll
do
is
disable
the
hot
ipfs
storage
and
we
could
just
look
at
some
of
the
other
things
that
we
could
configure
here
like
in
cold
storage.
Replication
factor
is
really
interesting.
Power
gate
will
actually
take
care
of
storing
your
data
in,
however,
many
miners,
you
specify
here
the
deal,
duration,
how
long
it
will
last.
If
there
are
any
miners,
you
definitely
don't
want
to
be
storing
data
with
you
can
specify
them
in
an
array
here.
B
Other
excluded
miners
same
thing:
if
there
are
miners
you
prefer
to
use,
you
can
specify
their
IDs
here
and
power
gate
will
give
those
miners
preference
country
codes.
If
you
know,
there's
geographic
areas
that
you
prefer
to
store
your
data,
you
specify
them
and
know
right
here
and
then
renew
power
gate
will
automatically
renew
any
deals
that
are
close
to
expiring
and
you
could
specify
how
close
to
expiring.
You
want
the
renew
to
happen
here
at
the
threshold
and
then
the
adder
here
is
the
the
wallet
address.
B
First
of
all,
we
had
to
add
the
data
just
to
the
cache
kind
of
on
our
ipfs
node,
that
is
running
alongside
a
Power
Gate
Way
power
gate
works
in
order
to
add
data
to
power
gate
you
just
add
by
CC
ID,
so
that's
the
ID
doesn't
need
to
be
pin
necessarily,
but
it
just
has
to
be
available
somewhere
on
the
ipfs
network.
So
just
to
ensure
that
was
true.
B
B
I've,
provided
this
watch
flag
and
watch
tells
the
CLI
to
do
this
thing
here,
where
it
kind
of
blocks
and
shows
the
job
status
which
just
succeeded
now.
So
we
know
it's
done
since
we
didn't
want
to
use
the
default
storage
configuration
right,
I
provide
that
C
flag
with
the
path
to
our
file
that
holds
that
custom
configu
want
to
use.
B
You
could
also
pipe
the
JSON
into
this
command
and
standard
in
you
want
to
that
also
works
and
then,
of
course,
the
CID
of
our
data,
and
so
we
we
pushed
it
and
then
we
were
watching
the
job
status.
We
saw
it
progress,
I,
don't
know
you
could
have
seen
some
information
in
the
log
here
on
the
right
as
well,
but
now
it's
successful
lead
story.
So,
let's
run
another
command.
Ffs
show
and
then
provide
the
CID
and
that's
going
to
give
us
the
current
storage
state
for
that
CID.
B
There's
a
job
ID
that
executed
it.
Our
data
CID
the
time
stamp,
that
this
happened.
Our
hot
storage
information,
which
I
can
tell
you.
This
is
a
little
misleading,
but
I
can
tell
you
this
is
actually
kind
of
like
the
disabled
state.
There
is
no
hot
storage
happening.
This
time
stamp
is
just
some
default
empty
timestamp.
B
So
that's
consistent
with
our
config,
our
cold
config
here
for
file
Coyne.
You
actually
see
our
list
of
proposals,
so
these
are
the
actual
storage
deals
that
were
executed
on
our
test
net
with
our
miner.
Here,
the
least
with
the
epoch
in
which
the
deal
became
active
our
deal,
duration,
yep.
So
you
can
see
the
state
of
our
deal
now.
B
B
There
we
go
okay,
so
the
log
command
will
basically
watch
a
stream
of
log
events
that
we
pay
API
provides
we're
basically
any
change
to
the
CID.
There
will
be
old,
some
log
output
that
we
can
see
updates
to
here.
So
back
so
keep
an
eye
out
over
here
for
we're
going
to
make
a
change
over
on
the
left
hand
side.
B
So,
let's
go
ahead
and
edit
our
configuration
file
and
since
we
were
previously
just
storing
data
in
file
Corinne,
now
that's
make
that
data
available
for
sure
now
on
the
ipfs
network,
so
I
enable
the
hot
storage
I'm
gonna
set.
Allow
unfreeze
to
true
just
to
explain
this
once
more
I
know:
Andrew
hinted
at
it
or
you
didn't
intend.
He
explained
it
well,
but
it's
really
really
cool.
B
Now,
let's
run
Tao
FS
show
and
our
CID
again
and
now
we
see
the
updated
storage
information
for
that
CID
has
changed.
We
now
have
a
real
hot
storage
configuration
here,
enabled
truths,
file,
size
and
a
valid
created
timestamp
and
nothing
changed
about
our
cold
storage.
But
if
we
were
running
on
a
on
the
test
net
or
on
the
main
net
many
miners
we
could,
we
could
have
added
more
replication
factor
or
country
codes
or
whatever
to
our
cold
storage,
and
that
would
be
reflected
here.
B
Let's
see
okay,
and
we
can-
we
can
go
over
here
now,
and
this
is
the
IP
FS
gateway
running
locally
on
my
computer.
Here
we
can
see
that
data
is
available,
and
then
this
is
the
public
IP
FS
gateway
on
the
internet
and
there
it
is
so
that
that's
I
think
mainly
what
I
want
to
show
you
with
the
CLI
and
I
hope
you
can
see.
There's
a
lot
of
potential
there.
B
One
thing
to
remember:
Andrew
mention
it
early
is
that
earlier
is
that
the
COI
is
just
built
on
our
go
client
library,
it's
just
part
of
our
the
power
gate,
repo
and
that
client
library
is
just
built
on
G
RPC
definitions
that
are
in
the
repo.
So
there's
a
lot
of
flexibility
in
the
stack
you
know
you,
anybody
could
build
a
new
client
in
any
language
that
supports
G,
RPC
and
anyone
wanting
to
build
or
integrate
power
gate
into
a
go.
Application
can
use
the
existing
go
client
same
one.
B
This
is
a
project
to
be
probably
seeing
some
screenshots
of
already,
but
we're
working
with
the
protocol
labs
on
using
power
gate
as
the
API
to
drive
this
awesome
file.
Client
web
UI,
front-end
I'll
leave
most
the
details
to
pooja
for
her
lightning
talk
later
when
she
presents
more
on
this,
but
just
real
quick.
You
can
see
how
some
of
these
concepts
map
really
nicely
to
power
gate
like
the
idea
of
a
user
profile
Maps
cleanly
to
an
ffs
instance
and
within
a
single
ffs
instance.
B
You
have
your
wallet
addresses
that
are
managed
by
that
single
instance.
You
have
the
files
in
their
their
storage
status
that
are
managed
by
a
single
ffs
instance:
information
about
file
coin
deals
and
so
on.
So
we're
really
excited
to
see
we
that
project
goes
it's
it's
been
great
to
work
on
and
that's
all
I've
got
so
back.
A
To
Heather
thanks,
Aaron
I
think
we're
almost
out
of
time,
but
let
me
just
I
guess
just
wrap
this
up
very
quickly.
So
Aaron
showed
you
a
lot
of
things
and
showing
it
over
a
CLI.
You
had
to
move
through
it
sort
of
slowly
so
I
hope
you
got
it
all,
but
just
to
kind
of
recap,
because
I'm
so
excited
about
how
much
is
packed
into
this
pretty
little
thing.
It
seems
but
file
coins,
storage,
deal
management
per
user
configurations
for
all
your
users.
Power
gates
got
it
IP,
FS
and
file
coin
interoperability.
A
Power
gates
got
it
doc,
horizon
API,
driven
I,
hope,
you're,
seeing
the
trend
widely
supported
and
typed
api's
I
wish
there
was
like
feedback
from
this
audience:
per
user
per
file,
control
storage,
caching
of
lifetime
deal
availability,
yeah,
okay,
so
long
term,
management
of
unfreeze
repair
and
renew
pow-pow-pow,
okay
cool
and
a
beautiful
open-source
UI
that
people
are
building
on
top
of
it
already
yeah
you've
got
it
so
I
wanted.
I
would
leave
you
with
that.
A
But
that's
that's
kind
of
the
exciting
direction
that
we're
going
is
letting
users
actually
have
their
own
data
sets
in
a
thread,
for
example,
and
put
their
own
storage
configurations
right
in
that
thread,
and
then
the
power
gate
can
execute
it
for
them,
and
this
is
where
painting
services
could
come
in
and
be
doing
some
really
epic
things
on
top
of
that.
So
hopefully
you'll
pick
it
up
and
try
it
out
and
you'll,
be
in
really
good
company,
there's
already
people
that
are
kicking
the
tires
and
checking
out
that
code.