►
Description
Writeable Gateways Discussion - presented by @RangerMauve at IPFS þing 2022 - Connecting IPFS - https://2022.ipfs-thing.io
A
So
for
readable
gateways
we
have
the
spec
now,
which
is
really
great
in
that
you
know,
I
can
see
the
spec
and
I
can
see
what's
available
there
and
there's
some
stuff
I
didn't
know
existed,
which
is
cool,
but
generally
you
know
we're
resolving
ipfsc
ids
to
some
files
or
some
sort
of
data.
We
might
be
getting
ranges
out
of
it,
some
other
niceties
and
similarly
we'll
we're
resolving
ipns
and
kind
of
seamlessly
doing
that
pathing
as
well.
A
Recently,
it
seems
downloading
car
files,
which
are
entire
blocks
of
data,
is
very
popular
and
we've
also
got
directory
listing,
which
I
think
should
be
a
bit
more
controversial.
But
that's
probably
a
whole
other
thing,
and
so
we
get
all
of
this
for
free
in
go,
which
is
nice
and
what's
cool,
is
in
kubo.
We
also
get
writable
gateways
built
in
which
I
think
hasn't
been
talked
about
too
much,
but
it's
actually
really
usable.
A
You
can
post
some
data
to
slash
ipfs
if
you
have
the
flag,
enabled
and
then
get
back
a
path
with
a
cid
to
the
new
data
or
if
you
have
an
existing
folder
structure
that
you
want
to
append
some
more
data
to
you
can
do
a
put
again
to
a
cid
and
a
sub
path,
and
you
can
add
a
file
to
it.
Similarly,
if
you
have
an
existing
folder,
you
can
delete
it.
A
Client
side-
I
didn't
know
it
standed
for
content
archives.
Until
recently,
I
was
just
like
okay,
it's
a
car
file.
Let's
just
take
the
name,
but
you
know
generally
it's
nice,
you
have
a
bunch
of
data,
put
it
into
a
single
file,
then
upload
it
to
web3.storage,
and
I
think
you
get
back
the
cid
or
I
guess
you
pre-computed
it
as
well.
A
A
That's
really
useful
insight,
yeah
and
also
the
thing
that
makes
it
easier
to
not
need
a
car
file,
but
also
not
just
do
single
files
is
form
data.
So
a
lot
you
know
the
web
has
been
dealing
with
file
uploads,
for
you
know
a
little
while
and
there's
a
standard
for
that
called
multi-part
form
data.
Where,
in
your
request,
you
encode
a
stream
of
files
and
upload
it
all
at
once
and
in
the
browser
we
have
apis
that
make
it
really
easy
to
use.
A
What
you
can
do
is
you
can
show
a
user
give
me
your
file,
upload
dialog
choose
whatever
files
you
want
and
then
add
them
directly
to
the
form
data
thing
and
then,
similarly,
you
can
post
that
to
ipfs
at
the
moment,
kubo
doesn't
support
form
data.
Web3.Storage
does
and
we
support
it
in
aggregor
for
uploading
files.
A
However,
that
file
name,
if
you
try
to
include
a
slash,
it'll,
just
kind
of
like
ignore
it
and
pretend
it
doesn't
exist,
so
I
think
in
the
browser
they
strip
it
out.
If
you
have
like
a
more
low-level
http
api
like
if
you're
doing
raw
curl
requests,
you
might
be
able
to
fudge
it,
but
generally
the
standard
doesn't
really
allow
for
subfolders.
So.
A
A
Okay,
you
should
come
to
the
ipld
thing,
I'm
doing
directly
after
this
in
some
other
room
that
I
don't
know,
but
I'm
actually
going
to
talk
about
escaping
raw
ipld
paths
that
can
not
play
nice
with
file
systems.
But
if
I
may
get
back
to
this,
you
know
form.
Data
is
useful
in
that
it
means
clients
can
be
a
lot
lighter
and
we
don't
need
to
generate
the
entire
dag
in
memory
and
do
all
of
that
processing.
A
A
Like
I
don't
know,
if
I
can
stress
it
enough,
because,
especially
if
you're
looking
at
doing
something
actually
peer-to-peer
where
you're
not
relying
on
a
third
party
to
do
your
mutability,
then
you
need
some
peer-to-peer
way
of
sending
those
updates
out
and
ipns
is
great
in
that
we
have
it.
There's
room
for
improvement,
but
it
gives
you
a
way
to
update
data
sets,
and
so
it's
similar
to
how
we
can
use
ipfs.
A
We
can
either
post
some
data
to
an
ipfs,
sorry
ipns
public
key
if
we
post
a
cid
that
can
update
the
record
and
publish
it
for
us.
Similarly,
I
was
working
with
lydle
on
this
with
the
agrigore
gateway.
We
have
a
way
to
create
ipl
ipns,
so
many
acronyms
ips
keys
within
the
gateway
which
might
be
a
potential
way
to
import
things
down
the
line
for
like
clients
and
as
well.
A
You
know
we
can
put
data
over
top
of
an
existing
ipns
tree
in
order
to
add
data
which
includes
stuff,
like
form,
data
or
deleting
files,
and
all
of
that.
So
this
is
nice
in
that
it's
kind
of
all
of
the
same
things
we
could
do
with
ipns
sorry
with
ipfs,
but
now
we
can
update
a
data
set,
send
somebody
that
mutable
link-
you
know
big
question
here
is
ipns
requires
private
keys.
How
do
we
actually
do
that?
A
A
Okay,
cool,
where
you
know
I'm
trying
to
think
what
is
how
can
we
integrate
this
stuff
really
closely
with
just
baseline
clients,
just
like
the
raw
language
and
kind
of
abstract
away
all
of
those
extra
dependencies?
And
all
of
that
extra
knowledge
that
you
need
to
run
an
ipfs
node?
And
so
in
agrigore
we
have
the
existing
mutable
gateway
functions
that
we
extended
a
little
bit
with
form
data
with
ipns
support.
A
So
I
think
that's
kind
of
the
state
of
writable
gateways
like
there's,
obviously
more
nuance
in
there,
but
that's
kind
of
the
high
level
of
how
people
interact
with
them
and
some
of
the
reasons,
some
of
the
trade-offs
between
the
methods
of
interaction.
So
I
guess
next
we
have
like
a
discussion
board.
I
have
some
potential
props
prompts
for
stuff.
We
can
say
like.
Are
there
any
questions
about
writable
gateways
or
like
thoughts?
A
Immutability,
I
think,
is
one
that
would
be
really
important
to
discuss,
because
applications
have
data
changing
over
time,
also
like
who
is
actually
using
these
gateways,
or
is
it
useful
to
people
and
are
also
which
of
these
features?
Can
we
standardize
on
because,
like
at
the
moment,
you
know
there
is
the
kubo
gateway,
but
it
seems
there's
more
and
more
divergent
implementations
that
maybe
could
work
on
standardizing
more
stuff.
Also,
is
there
anything
that
got
brought
up
that
you
were
like
wow?
I
didn't
know
that
was
an
option.