►
From YouTube: IPFS API – Building a Go Application with the IPFS API
Description
Start playing around with implementing IPFS in a go application, using the IPFS API. In this tutorial, you will learn how to: Add a file to IPFS, read the file from IPFS download the file to your computer, add the file to IPNS, and read the file from IPNS.
This content is created as a part of Protocol Labs' Launchpad program. You can get resources and written instructions in our learning platform at https://curriculum.pl-launchpad.io/curriculum/ipfs/ipfs-api/
Find out more about Launchpad and Protocol Labs in our website: https://pl-launchpad.io/
00:00 Start
00:30 Prerequisites
00:59 Coding time!
01:28 Review the "main" Function
02:04 Add a File Using the IPFS API
02:39 Read a File Using the IPFS API
03:35 Download a File Using the IPFS API
03:59 Publish a File to IPNS Using the IPFS API
05:15 Retrieve an IPNS Record Using the IPFS API
A
The
main
implementation
of
ipfs
Kubo,
previously
known
as
oipfs,
exposes
an
HTTP
API
that
you
can
use
to
interact
with
an
ipfs
node
paramatically.
Basically,
it
allows
you
to
use
the
apfncli
commands
through
an
HTTP
API,
although
you
can
directly
send
HTTP
requests
to
the
API
in
this
tutorial,
we
are
going
to
use
a
go
client.
A
First,
in
a
command
line
terminal
and
start
a
new
ipfs
node,
which
is
going
to
expose
the
API,
then
make
sure
that
you
have
go
installed
and
if
you
don't
have
it
already
clone
the
Launchpad
tutorials
repository,
which
contains
the
templates
that
you
will
use
in
this
tutorial.
You
will
also
need
the
public
key
of
your
ipfs
node.
You
can
List
It
by
using
the
apfs
key
command.
A
To
modify
the
go
code,
I
will
use
Visual
Studio
code,
but
any
other
ID
is
okay.
First
I
will
open
the
launch
by
tutorials
repository
the
ipfs
go.
Client
folder
contains
two
subfolders
in
the
upsub
folder.
You
will
find
a
template
to
complete.
I
will
also
open
the
integrated
terminal
of
Visual
Studio,
where
the
code
will
be
executed.
A
You
can
see
there
are
several
functions
to
be
implemented.
The
main
function
calls
the
helper
functions
and
handles
the
results.
The
first
thing
we
do
in
the
main
function
is
creating
a
new
client.
The
new
shell
function
returns
a
client
that
contains
all
the
methods
to
interact
with
the
ipfs
node
as
a
parameter.
We
provide
a
URL
of
the
ipfs
API
with
a
default
Port.
Now
that
we
have
the
client,
we
can
pass
it
to
the
different
helper
functions
to
create,
read
and
download
an
ipfs
file.
A
Now
we
are
going
to
complete
the
add
file
function,
which
will
create
a
new
file
with
a
text
that
we
pass
as
a
parameter.
First,
we
remove
the
comment
and
we
use
the
add
method
of
the
client
which
Returns
the
CID
of
the
file,
if
added
correctly
to
ipfs.
If
not
an
error
is
returned,
we
have
to
provide
our
reader
to
the
add
method
in
go.
You
can
create
a
reader
from
an
external
file
or
a
stream.
In
this
case,
we
are
creating
a
reader
from
a
string.
A
Now
we
can
move
on
to
the
next
function.
To
read
the
file,
we
use
the
catch
method
of
the
shell.
We
have
to
provide
the
ipfs
path,
which
contains
the
CID
of
the
file
we
are
looking
for.
The
cath
method
returns
two
parameters,
a
reader
and
an
error.
In
the
case
of
an
error,
the
other
variable
will
be
populated
in
our
code.
If
the
error
variable
is
populated,
we
stop
reading
the
file
and
we
return
an
empty
string.
The
reader
is
an
abstraction
for
the
content
of
a
file.
A
Therefore,
we
have
to
go
from
a
reader
to
a
string,
First
We
Take,
the
bytes
from
the
reader
by
using
a
helper
function.
Again,
we
check
for
errors.
In
the
case
of
an
error,
we
stop
the
flow
of
the
program
and
we
return
an
empty
string.
Finally,
we
convert
the
bytes
to
a
string
and
we
return
the
text
variable.
Now
we
can
move
on
to
the
next
function.
A
To
download
the
file,
we
use
the
get
method
from
the
shell,
which
expects
two
parameters:
the
CID
of
the
file
and
the
path
in
your
local
computer,
where
the
file
will
be
stored.
This
code
template
contains
a
constant
where
you
can
set
your
local
path.
In
my
case,
I'm,
going
to
use
a
documents,
folder.
A
In
the
next
function,
we
are
going
to
publish
an
ipns
record
to
publish
the
record.
We
use
the
publish
with
details,
method
from
the
client
which
expects
five
parameters.
The
first
parameter
is
the
CID
of
the
file.
The
second
one
is
the
public
key
of
your
ipfs
node.
The
third
one
is
the
amount
of
time
that
the
record
will
be
valid
for
the
fourth
one
is
the
amount
of
time
that
ipns
will
cache
the
record,
and
the
last
parameter
indicates
whether
the
client
should
check
if
the
ipns
record
already
exists.
A
The
code
template
contains
a
constant
where
you
can
set
your
public
key,
just
copy
and
paste
your
public
key
here.
Next
we
are
going
to
create
the
missing
variables.
Both
variables
must
be
of
type
duration,
I'm
going
to
set
the
lifetime
variable
to
50
hours.
Therefore,
the
ipns
record
will
be
valid
for
50
hours,
I'm
going
to
set
a
GTL
variable
to
1
microsecond,
so
that
ipns
doesn't
cache
the
record
selling
a
low
cache
time
means
that
if
you
update
the
record,
it
will
be
replaced
immediately.