►
From YouTube: Hyperledger Fabric external chaincode service
Description
A recording of Hyperledger Sweden's regular Tech Study Circle that covers cover basic concepts behind the Hyperledger Fabric external chaincode service and how techniques like buildpacks work and what changes to the test network are required.
More about the event is at: https://www.meetup.com/Hyperledger-Sweden/events/ctplzrybcpbjb/
----
Hyperledger – Open Source Blockchain Technologies
Hyperledger is an open source community focused on developing a suite of stable frameworks, tools and libraries for enterprise-grade blockchain deployments.
It serves as a neutral home for various distributed ledger frameworks including Hyperledger Besu, Fabric, Sawtooth, Indy, as well as tools like Hyperledger Avalon, Cactus and libraries like Hyperledger Aries, Ursa. Learn more about Hyperledger projects: https://www.hyperledger.org/use
Case Studies: https://www.hyperledger.org/learn/case-studies
Training & Certification: https://www.hyperledger.org/learn/training
Tutorials: https://www.hyperledger.org/use/tutorials
Webinars: https://www.hyperledger.org/learn/webinars
Events: https://www.hyperledger.org/events
Vendor Directory: https://www.hyperledger.org/use/vendor-directory
Subscribe to the Hyperledger Newsletter: https://www.hyperledger.org/newsletter
Follow-us on Twitter @Hyperledger
Learn about Hyperledger Membership: https://www.hyperledger.org/about/join
#Hyperledger #HyperledgerMeetups #Blockchain
A
A
I
would
like
to
point
out
that
if
you
have
any
questions
or
you
would
like
to
see
a
particular
topic,
then
you
can
drop
me
an
email
or
write
it
in
the
slack
channel
or
whatever,
and
I
can
see
I
can
bring
it
in
to
this
series
and
we
can
we
can
discuss
about
this
and
I
can
show
you
how
you
can
do
this.
So
the
whole
series
is
from
the
community
to
the
community
and
it
lives
also
from
the
community.
A
So
I
I
I
like
your
feedback
and-
and
you
can
say
what
you
want
and
then
we
can
look
how
we
can
make
this
possible
and
of
the
other
side.
You
can
also
try
to
make
a
session
and
yeah,
and
then
you
can.
We
can
arrange
one
session,
I
think
so.
So
there
is
one
question
to
the
slides.
You
find
the
slides
in
the
in
the
chat
a
little
bit
below
your
comment,
and
I
think
I
have
done
as
a
test
for
the
for
the
for
this
for
the
voice.
A
A
One
short
theoretical
part:
how
we
can
do
this.
What
is
the
difference
between
this
external
chain
code
service-
and
this
is
a
little
bit
advanced
feature
and
we
have
to
do
some
specific
tasks
to
get
this
running,
but
on
the
other
side
we
can
see
also
how
the
traditional
way
is
working-
and
this
is
a
very
good
part
to
understand-
or
a
very
good
way
to
understand
how
fabric
works
with
docker
and
how
a
chain
code
container
is
builded
and
so
on.
A
So
maybe
some
of
you
have
heard
of
this
and
or
use
this
this
technique.
So
this
is
a
technique
which
is
related
to
container
technology,
and
this,
I
think,
a
really
handy
way
to
build
your
containers,
and
this
example
shows
that
hyperledger
fabric
is,
is
a
technology
which
uses
a
lot
of
technologies
around
a
lot
of
cloud
native
technologies,
and
you
can
use
these
technologies
as
well,
not
only
in
the
hyperledger
fabric
world,
so
you
can
only
use
it
for
your
own
development.
A
A
So
we
are
going
to
set
up
the
new
test
network
for
this
scenario
and
we
will
look
a
little
bit
more.
We
will
learn
more
about
the
test
network,
so
we
will
look
in
the
script
folder,
so
we
can
use
the
scripts
to
to
to
change
between
the
organizations
so-
and
I
will
show
you
how
you
can
do
this
and
what
is
important
in
this
step.
We
will
also
look
into
the
docker
compose
file
for
the
first
time
in
this
series.
A
So
that's
a
good
point
where
we
can
look
in
this
docker
compose
file
because
we
have
to
make
some
changes
in
this
file
and
then
we
can.
I
can
explain
what
is
this
docker
compose
file
for
and
what
are
the
relevant
parts
of
this
and
yeah,
and
we
have
to
look
into
the
so-called
config
or
our
core
yaml
file,
because
we
have
also,
I
have
to
make
some
changes
in
this
file
and
then
we
are
going
to
use
the
external
chain
code
service
so,
but
we
will
make
it
twice.
A
So
we
are
going
to
make
an
example
with
an
external
chain
code,
and
then
we
will
compare
it
with
an
internal
chain
code.
So
then
you
can
see
we
can
have
a
one
ledger,
one
channel,
and
on
this
channel
we
can
install
a
chain
code
with
the
traditional
way.
I
call
it
internal
and
an
external
chain
code
which
is
used
with
an
external
change,
server
and
yeah.
The
agenda
you
can
find
here
as
well
for
this
meetup
and
for
the
upcoming
meetups
here
are
the
links,
the
support
link.
A
A
The
test
network
is
an
organization
with
two
peer
organizations,
and
each
peer
organization
has
one
peer
and
we
have
one
other
organization
with
a
single
weft
ordering
system,
and
then
we
have
a
lecture
which
connects
this,
these
organizations
together
and
then
we
have
a
channel.
This
is
the
my
channel
or
channel
one
here,
and
then
we
will
install
two
chain
codes
here,
both
chain
codes.
A
So
okay,
internal
chain
code
versus
external
chain
code
service,
so-
and
I
think
the
first
sentence
here-
keep
it
keeps
it
to
the
point
here.
Instead
of
building
and
launching
the
con
chain
code
on
each
sphere,
train
code
can
now
run
as
a
service
whose
life
cycle
is
managed
outside
of
favorite.
So
this
sentence
is
copied
from
the
official
documentation
and
I
think
that's
that
keeps
it
really
to
the
point.
Then
the
chain
code
is
run
in
a
single
container.
A
So
when
the
br
the
chain,
when
the
chain
code
is
installed
on
one
pr,
then
the
chain
code
will
execute
it
and
when
the
chain
code
is
executed,
it
will
execute
it
in
an
in
in
a
different
chain
code
container
and
in
version
one
this.
This
was
a
fixed
process.
This.
This
is
hard
coded
in
the
in
the
system
and
you
can't
change
it,
and
this
is
a
requirement
which
came
in
and
innovation
version
2.
They
have
launched
this
feature
and
they
used
decoded
external
pillar
and
launcher.
A
A
A
You
find
the
use
case
for
this
so
but
I
think
that's
not
the
normal
use
case,
so
you,
you
must
have
a
use
case
where
you
can
use
this
scenario
so
because
it
is
a
little
bit
an
overhead
to
do
this
and
yeah
so
in
the
documentation.
There
is
a
point
when
you
use
fabric
in
kubernetes
cluster,
then
it's
maybe
that's
a
good
choice
to
use
this
for
for
the
chain
code
and
but
in
theory
it's
like.
A
We
know
when
this
container
is
started
and
build
up
and
in
when
we
have
a
chain
code
server
and
that's
also
an
important
part.
So
you
have
you
have
to
know
that
when
you
use
this
new
service,
then
you
have
to
adopt
your
chain
code
as
well,
because
we
need
a
chain
code
server
and
that's
maybe
a
little
bit
a
restriction.
A
A
Your
change
your
chain
code
and
you
have
to
use,
go
as
the
language
for
this,
but
we
will
see
what
we
have
to
do
is
what
we
have
to
to
use
and
what
are
the
steps
which
we
have
to
do
so
the
process
is
basically
the
same
as
we
have
seen
in
the
last
session.
We
have
to
first
we
have
to
package
the
chain
code,
but
here
we
have
a
different
difference.
A
So
this
without
the
chain
code,
as
we
have
seen
in
the
last
session
in
this
package,
there
are
some
files
that
that's
entire
gt
file
and
there
we
will
have
a
meta
file.
We
have,
we
will
have
a
connection
json
file
and
we
will
have
the
chain
code
as
well
and
in
this,
when
we
package
this,
we
don't
need
the
chain
code,
because
the
chain
code
will
will
be
built
in
a
separate
container
and
will
be
started
in
a
separate
process.
So
that's
the
difference
in
the
packaging
process.
A
A
And
for
this
we
have
to
look
into
the
query
armor
file
and
there
is
a
file
which
will
comes
with
the
fair
examples
and
we
can
use
this
and
then
we
have
to
print
bind
this
in
the
docker
compose
file
as
a
local
volume
so
that
we
can
use
it
in
the
dpr
container.
So
and
that's
the
reason
why
we
can
dive
into
the
docker
compose
file.
So
we
have
to
modify
two
things:
the
code,
this
square
armor
file,
and
then
we
have
to
adjust
the
docker
compose
file.
A
So
in
a
way
that
this
is
working
and
then
we
can,
we
have
to
look
a
little
bit,
but
we
we
don't
have
to
change
anything.
So
we
can
use
the
default
example
for
this
and
we
have
to
look
into
these
launcher
scripts.
So
this
external
builder
and
launcher
are
basically
some
scripts
and
these
scripts
detect.
What
is
what
is
your
your
source
code
for
and
then
in
the
end,
it
will
build
for
you
a
container,
but
in
the
in
the
in
the
fabric.
A
This
is
a
little
bit
adopted,
and
so
we
don't
need
to
change
so
much
in
this.
So
we
can
only
look
into
this
and
and
see
what
is
it
what
it
is
for
and
then
we
have
to
change
the
chain
code
as
well.
So
the
differences
is
in
the
main
function.
We
will
see
it
a
little
bit
later,
so
it's
not
really
difficult,
but
we
have
to
do
it
and
then
we
can
deploy
the
chain
code
and
that's
the
same
way.
A
That's
that
we
would
that
will
be
doing
the
same
way
as
we
have
done
in
the
last
session,
so
we
have
to
install
it.
We
have
to
improve
it
and
then,
when
the
when
the,
when
the
majority
of
the
organization
have
improved
the
chain
code,
then
we
can
commit
it
and
then
the
tranquil
should
be
ready
for
the
invoke
and
query
command
and
of
course
we
have
to
start
this
external
service
with
yeah.
We
have
to
do
it
by
hand
in
our
case
and
yeah.
A
A
And
yeah,
so
these
are
basically
the
steps
which
we
are
going
to
do,
and
these
are
the
chain
code
comparisons.
So
the
normal
chain
code
is
in
the
main
function
we
have
here
in
the
first
line,
you
can
see
the
the
important
source
code
snippet,
so
we
have
here
the
new
chain
code
command
and
we
have.
We
have
it
also
here
so,
and
the
only
difference
in
this
that
we
have
to
use
this
chain
code
from
the
shim
package.
A
The
chain
code
server
object
here,
and
then
we
have
to
deliver
some
properties
to
this
to
this
object,
so
the
chain
code
id.
This
is
also
something
we
have
seen
in
the
last
session.
This
is
the
package
id
or
the
chain
code
id
which
we
will
receive
when
we
installed
the
chain
code
and
then
the
address
this
address
came
also
from
the
package
process.
We
will
see
it
a
little
bit
later
and
then
the
name
of
the
chain
code
itself,
and
then
this
is
the
part
where
we
have
when
you
use.
A
This
is
the
server
config
object
with
the
environment,
variables,
chaincode
id
and
jcode
server
address,
and
this
information
will
come
from
the
chain
count
environment
file
which
we
will
see
later
so
and
with
this
you
have
a
bridge.
So
we
have
an
environment
file
and
then
this
environment
file.
We
will
define
these
two
environment
variables
and
in
the
chain
code,
we
will
read
this
environment
files
here
in
this
counting
object,
and
then
it
will
delivered
here
to
the
chain
code
server
and
that's
it.
So
these
are
the
these
are
the
points.
A
These
are
the
points
we
have
to
modify
when
we
would
like
to
use
our
chain
code
as
an
external
chain
group
service.
So,
and
the
main
thing
is
here
that
you
cannot
use
your
standard
chain
code,
so
you
have
to
modify
it
and
you
have
to
do
some
things
more
when
you
would
like
to
use
the
tls
here
for
the
chaincode
server
here,
and
we
will
see
it
later
also
in
the
chain
code.
But
here
this
is
the
the
main
thing
here,
what
you
have
to
change
when
you
drink.
A
So
this
is
a
short
side
note
on
what
are
buildbacks.
I
I
think
I
mean
that's
about
it's
not
so
related
to
fabric.
I
think,
but
I
think
that's
an
important
part
that
you
understand
and
that
you
see
that
favoritis
technology,
which
consumes
a
lot
of
standard
technologies
and
built
a
new
thing,
and
that
is
called
fabric
and
the
buildbacks.
A
A
Or
whatever,
and
then
you
can
on
this
on
this
container,
you
will
have
your
node
application
running
your
go
application
running
your
bhp
application
or
whatever
your
database
server
whatever.
So
in
every
case,
you
need
an
operating
system
or
parts
of
the
operating
system
in
this
container
and
in
some
times
yeah.
A
You
have
to
update
this
and
with
the
rebase,
you
can
do
this,
so
you
can
update
the
container
only
the
base
image
and
not
your
application
so,
and
I
think
that
this
is
a
good
way
to
to
do
this
and
yeah.
So
these
are
also
informat
bullet
points
from
the
documentation
so
pitch
backs.
Only
the
only
the
only
the
only
reason
for
pitchbacks
is
to
create
runable
application
images
directly
from
your
source
code
and
that's
also
an
interesting
part.
A
So
when
you
use,
for
example,
a
node.js
application
and
in
this
nodejs
application
you
will
have
an
express
web
server,
then
you
have
to
install
with
npm
some
packages
express
and
other
packages,
and
the
big
bags
do
that
for
you.
So
they
do
this.
Do
all
the
the
this
stuff
they
do.
The
nbm
install
and
installs
the
requirements
for
this
application
and
build
your
app
and
that's
a
good
way
to
do
this
so
and
yeah.
A
The
result
is
an
open
container
image,
an
oci
image,
and
this
is
in
one
vulnerable
image
for
any
container
a
platform.
So
in
my
example,
I
will
use
the
google
cloud
builder
and
for
this-
and
you
will
see
that's
really
easy
to
do
this
in
this
way,
and
so
they
say
the
main
focus
is
on
writing
code,
not
to
containerize
it.
So
that's,
basically
a
point
for
developers.
So
when
you
write
some
code
and
then
you
need
a
container
for
this,
then-
and
you
need
the
secure
container
for
this-
then
you
can
use
this.
A
So
everything
comes
with
with
the
favorite
examples
only
when
you
use
it
for
your
own
for
your
own
examples
for
your
own
purpose,
then
you
have
to
install
this
these
pack
packages
and
but
I
will
show
you
later
how
you
can
find
this
and
what
you
have
to
install,
but
for
in
the
case
of
favorite,
you
don't
have
to
install
anything
to
use
this.
Everything
is
done
with
the
fabric,
samples
and
the
rebase.
A
That's
I
think,
that's
for
me.
The
the
interesting
interesting
part
that
we
can
update
the
underlying
operating
system,
a
debian
or
ubuntu
system
and
yeah.
So
I
think
that's
a
cool
process,
yeah
and
then
here
short,
so
when
we
have
time
enough,
then
we
can.
I
can
show
you
how
we
can
build
a
nodejs
application
with
the
google
cloud,
build
packs,
for
example,
so
because
they
are
called
they
are
new.
A
So
when
we
have,
we
have
a
nodejs
application.
So
that's
the
the
point
of
view
from
a
developer
so
develop.
The
developer
develops
a
nodejs
application,
for
example,
and
the
aim
is
that
this
application
should
run
in
a
container
environment
and
then
he
has
to
create
an
docker
container,
for
example,
and
with
this
buildback
you
can
do
this
in
a
very
easy
way,
and
this
buildback
yeah
in
the
first
step,
could
is
need
a
build
image.
A
So
the
build
image
is
something
like
an
ubuntu,
for
example,
or
an
dbn
or
an
alpine
linux
or
whatever,
and
then
they
have
these
buildbacks,
and
this
is
called
the
the
first
step.
The
builder
image-
and
this
buildbacks
is,
as
I
have
mentioned
earlier-
a
set
of
scripts
which
is
available
and
it
yeah
it
tries
to
analyze,
inspects
your
source
code
and
from
this
information
it
tries
to
formulate
the
plan
to
build
and
run
your
application.
A
So
when
it
comes
to
the
notion,
what
does
this
mean?
So
that's
a
nice
sentence,
but
what
does
this
mean?
So
that
means
that
when
we
have
a
nodejs
application,
this
inspect
this
first
in
the
first
step,
he
is
looking
maybe
for
a
package.json
file
and
when
they
find
the
package.json
file,
they
say:
okay,
that's
a
nodejs
application
and
then
install
this
npm
this
this
package,
this
package.json
file
and
and
then
the
builder-
means
that
there's
a
nodejs
application
and
builds
this
application.
A
And
then,
in
the
end,
we
have
an
application
image
which
can
used
as
as
any
other
docker
image.
And
then
we
have
this
one
image
here
and
we
have
this
application
and
the
one
image
here
is
on
the
build
image
when
we
set
when
we
say
build
damage
here
and
the
build
image
is
in
also
in
the
new
image
then,
and
then
on
top
of
this
build
image.
A
There
is
the
application,
and
that
leads
to
the
final
one
so
and
the
rebasing
is
an
process
that
we
can
change
the
the
build
image
here
and
but
we
will
not
change
the
application
code
here.
So
we
only
change
the
underlying
image
here,
and
this
is
maybe
an
a
newer
version
of
a
ubuntu,
a
newer
version
of
debian
and
so
on.
A
So,
but
the
application
itself
will
not
be
affected
from
this
process
and
it's
also
a
fast
process
here.
So
I
think
that's
an
interesting
concept
and
many-
and
this
is
used
in
many
larger
applications.
So
it's
definitely
it.
It
is
worth
to
have
a
look
in
this
and
see
how
you
can
use
it
for
your
own
purpose.
A
A
A
A
Everything
is
the
same,
so
we
can
use
this
network
network
script
and
boot
our
network,
but
before
we
can
do
this,
we
have
to
do
some
small
modifications
and
the
third
examples
has
a
small
has
an
example
and
this
example.
We
are
going
to
use
now
and
for
this
this
example,
we
will
find
in
the
asset
transfer
basic
folder,
and
there
is
a
folder
chain
code
chain,
code,
external
and
we
are
going.
A
A
So
the
only
thing.
What
is
here
interesting
is
the
address
so
and
the
address
for
this
is
this
one,
and
here
is
a
timeout.
So,
for
example,
we
can
leave
this
as
it
is
and
we
don't
have
to
modify
this
file
and
the
second
thing
is
the
chain
code
environment
file
which
I
have
mentioned
before,
and
here
we
will
have
two
environment
variables.
A
A
A
So
this
is
the
asset
transfer
go
chain
code
here
this
this
asset,
but
we
don't
need
it
in
the
first
step.
So
we
need
it
later
when
we
create
the
docker
image
with
this
docker
file
and
then
in
this
chain
code
container
in
this
docker
container,
the
chain
code
will
be
installed
and
also
all
dependencies
and
because
it,
the
chain
code
should
run
as
an
external
service
and
should
not
part
of
the
favorite
in
this.
In
this
scenario,.
A
But
now
we
do
it
by
hand
and
the
result
is
these
as
a
transfer
basic
file-
and
this
is
the
and-
and
this
is
the
package
chain
code
which
we
are
going
to
install
on
the
peers
later
and
yeah.
So
I
have,
I
copied
the
chain
code
environment
file
in
the
test
network
directory,
so
so
I
don't
have
to
switch
between
these
directories
every
time.
A
A
We
have
a
folder,
it's
called
config
and
there
is
a
fold
and
there
is
a
yama
file.
It's
called
it's
called
core
yaml
and
then
the
scroll
yaml
file
as
it
is
packed
here,
is
the
original
one
and
on
line
549
there's
the
part
which
we
are
interested
in.
So
this
external
tildes,
and
here
we
have
to
do
the
modification.
A
But
let
me
point:
let
me
point
to
this
to
this
brackets
here.
So
I
think
this
brackets
are
wrong
in
this
file
and
because
it's
a
yummy
file-
and
I
have
to
remove
it-
and
I
have
changed
this
to
this-
so
so
my
my
scenario-
it
it
doesn't
work
with
this
brackets
here.
So
maybe
that's
that's
wrong
here,
because
this
file,
this
file,
is
copied
only
for
for
this.
For
for
this
favorite
samples-
and
you
will
not
find
this
conflict
directory
in
the
on
the
official
github.
A
So
when
you
look
at
the
official
github,
where
you
can
download
the
fabric
samples,
then
you
will,
you
will
not
find
this
config
directory,
so
this
will
come
through
the
installation
process
and
also
with
this
configt
xml
files
and
the
autoimma
file.
For
example,
so,
but
I
think
we
have
to
make
this
corrections
here.
A
One
file
so
okay
and
yeah-
and
this
is
the
part,
the
external
pillars,
and
we
have
to
do
two
things
here.
We
have
to
define
the
path
where
the
external
pillars
files
are
located,
but
be
careful
here.
This
is
not
the
part,
the
path
on
your
local
machine,
so
that
is
the
path
in
the
container
so
in
the
pier
container.
So
we
have
to.
A
We
have
to
be
careful
and
look
when
when
we
mount
this
local
favorite
samples
directory,
we
have
to
mount
it
on
this
position
here
and
yeah,
but
we
will
see
it
then
later.
So
this
is
the
first
first
thing
we
have
to
do
and
the
second
is:
we
have
to
give
them
a
name
so
and
this
I
think,
that's
only
for
logging
external
sample
builder.
This
is
yeah
default
and
these
properties
here
we
are
not
needed
now.
So
because
we
don't
need
in
our.
A
In
our
scenario,
we
don't
use
the
tls
for
the
chaincode
server
and
that's
an
interesting
part.
So
I
have
to
say
I
haven't
figured
out
how
we
can
do
this
now.
So
if
you
have
time,
then
you
can
make
your
hands
or
your
finger
dirty
and
find
out
how
you
can
set
up
the
chaincode,
the
chaincode
server,
with
the
tls
configuration.
So
for
that
it
was
too
too
less
time
for
me
to
figure
it
out,
and
I
never
find
any
example
in
this
direction.
A
A
And,
as
you
can
see
here,
we
have
a
typical
composer
file
structure.
So
we
have
here
in
the
first
in
the
first
line
here
some
volumes,
so
we
have
a
volume
for
the
order
for
the
peers
and
for
the
peers
for
ps0
from
organization,
one
and
organization.
Two,
then
we
have
this
test
network
name
and
then
we
have
three
services
and
that's
a
big
difference
between
the
version
one,
because
we
have
only
one
order.
We
have
this
order
here
and
we
have
only
two.
A
We
have
only
one
peer
for
each
organization
and
we
don't
have
any
any
nacli
container
here,
because
we
don't
need
it
anymore
in
the
version
two,
and
when
you
look
into
this
order
configuration
you
will
see
here
some
important
points.
So
these
environment
variables
here
will
be
overwrite
all
values
in
decoy
yaml
file,
which
I
have
shown
you
some
minutes
ago-
and
this
is
very
important,
especially
for
the
tls.
A
So
here
you
can
create
tls,
and
but
we
have
to
use
tls
here,
because
that's
in
rust
order
and
raft
can
only
work
with
tls,
so
tls
must
be
enabled
here.
So
when
you
use
version
1.4,
6
or
9,
or
something
like
that,
then
you
can
have.
As
for
your
test
scenarios
and
for
your
for
your
trainings,
you
can
use
the
solo
aura,
for
example,
and
the
solo
aura
doesn't
need
any
tls
so
and
with
this
you
can
use
a
little
bit
the
complexity,
to
focus
on
specific
tasks.
A
You
are
going
to
investigate
in
this
part,
so,
but
over
here
this
important
part.
So
all
environments,
variables
here
and
this
environment
is
very
override.
The
values
in
the
core
yaml
file
and,
as
I
have
mentioned
last
time
so
the
the
the
naming
here
and
the
the
the
art
of
writing
this
environment
variables
is
a
little
bit
different
to
decor,
yaml
values
and
properties
which
are
in
this
file.
A
So,
but
this
we
have
to
discover
in
the
other
session
or
in
a
separate
session,
some
environment
are
variables,
for
us
could
be
important,
so
this
is
an
important
one.
So
this
lock
logging
one.
So
here
you
can
use
a
debug
for
example,
then
you
will
have
more
outcome
on
there
on
the
console,
for
example
and
yeah,
then
we
have
the
working
gear
directory.
So
I
think
that's
is
pretty
standard
you
can.
A
We
can
use
this
as
it
is,
and
also
the
parts
here
so
be
careful
with
the
board
and
then
what
we
have
here
to
look
is
the
volume.
So
you
have
to
see
here
that
the
other
needs
to
be
have
to
be
access
to
the
against
this
blog,
and
we
have
so
include
as
well
the
membership
service
provider
here,
and
so
that's
a
really
really
important
part.
What
is
a
membership
service
provider
in
the
world
of
ferric
and
we
will
spend
one
meeting
one
meetup,
especially
on
on
this
one.
A
A
So
that
means
that
we
will
have
a
persistent
network
so
and
with
this
with
this
configuration
here,
you
can
make
your
network
persistent,
and
that
means
that
when
you,
when
you
tear
down
your
your
network,
then
the
data
will
be
stored
and
will
will
not
be
deleted.
But
not
in
this
scenario,
when
you
use
the
network
networks,
when
the
net
this
network
script
and
network
down,
then
everything
will
be
deleted,
but
this
is
not
depend.
It
depends
not
on
this
on
this.
A
On
this
volume
it
depends
on
the
config
on
the
on
the
script
which
tear
downs
the
network
here
and
in
the
beer
section.
It's
basically
the
same.
You
have
also
here
the
environment
variables
you
have
the
container
names
and
so
on,
and
that's
also
important
when
it
comes
to
a
point
where
you
say:
okay,
I
would
like
to
get
rid
of
this
one
example.com.
A
So
I
would
like
to
have
my
own
organization
name
here.
Then
we
have
to
rewrite
this
container
names,
the
service
names
and
so
on
so
and
yeah,
but
be
careful
with
that.
So
when
you
start
with
with
this,
then
you
have
to
know
what
you
are
doing
and,
and
you
have
to
change
a
lot
of
names.
So,
as
you
can
see
here,
then
you.
So
it's
really
really
a
lot
to
change
here
when
we
would
like
to
change
this
domain
names
here.
A
It's
a
good
idea
to
try
to
write
the
script
which
replaces
this
container
names.
So
then,
because
there
are
some
some
many
many
points
we
have
to
change
here,
but
yeah,
so
here
also
the
debugging.
So
here
you
see
the
debug
word,
so
you
can
say:
okay,
we
want
this
lock
level
or
we
want
another
log
level
here
and
then
your
documentation,
you
find
also
other
log
labels.
A
A
It
won't
work
when
I
have
this
enabled
so
and
that's
the
reason
why
I
have
committed
this
out
for
for
this
demonstration
and
yeah,
and
here
we
have
our
modem
modification
so
for
the
external
chaincode
launcher
for
this
external
chaincode
service,
we
don't
have
to
change
anything
here
in
the
order
section
in
the
other
service.
Here
we
have
to
change
here.
A
We
have
to
change
here.
The
volume
on
the
and
and
at
this
volume-
so
we
add
the
the
we
have
to
add
the
favorite
samples
and
we
have
to
add
the
where
we
have
to
override
the
coil
yaml
file
with
our
file,
which
we
have
modified
in
the
configuration
directory
so
and
these
two
volumes
we
have
to
modify
here
and
then
we
have
to
commit
out
the
chain
code
address
and
the
chain
code
listen
address
so,
but
with
this,
I'm
not
really
sure.
So,
in
my
case,
it
works.
A
So
that's
here
and
in
this
way
and
yeah
so
and
and
then
other
different
is
here
that
we
don't
have
this
space
pfi
this
space
via
yaml
files.
So
in
this
in
the
fabric,
two
examples:
everything
is
here
in
this
docker
compose
file,
and
this
is
also
a
change
from
the
version
one
to
the
version
two
here.
A
Okay,
so-
and
these
are
the
modification
for
this
docker
compose
file
yeah.
So
this
is
this
and
then
we
should
be
ready
to
start
this
network,
and-
and
this
is
an
important
point,
so
I
would
like
to
recommend
when
you
try
a
lot
of
you
use
a
docker
system
prune
in
front
of
this,
and
this
is
a
good
and
easy
way.
So
when
we
call
this
so
we
will
stop
all
containers
and
networks
and
so
on
and
yeah.
A
A
The
three
examples
comes
with
some
helper
scripts
and
when
you
start
with
that,
you
can
it's,
it's
very
handy
to
use
it.
So
there's
an
environment,
var
script,
which
provides
some
environment,
some
shell
functions
and
one
of
them
is
the
set
globals.
And
with
this
set
global's
function,
we
can
easily
switch
between
the
organization,
one
and
organization.
A
A
And
then
so
I
have
to
look
if
I'm
on
the
right
position.
If
this
is
right
and
the
first
step
is
now-
we
have
to
install
the
chain
code
yeah
and
now
we
are
going
to
install
the
chain
code
which
we
have
packed
before
for
the
organization,
one,
but
notice
that
that
this
install
process
is
now
without
indigo
chain
code.
A
So
and
then
you
see
that's
pretty
fast,
because
the
chain
code
container
is
not
tilted
in
this
process
now
and
when
we
will
use
the
traditional
way
later
and
then
we
will
see
this
process
will
take
some
seconds
because
the
chain
code
has
to
has
to
be
built
and
did
take
some
time.
And
here
you
can
see
this
ident
tranquil
identifier.
A
This
is
that's
what
we
are
looking
for,
so
for
our
environment
variable
and
for
the
yeah
for
the
environment
variable
so
the
chain
code
name
and
the
hash
value
of
this,
and
but
we
can
use
it
with
the.
We
can
get
this
information
later
with
the
query
installed
parameter
as
well,
so,
okay,
so
organization,
one
is
done.
So
we
are
going
to
do
this
with
organization.
True
and
then
we
have
to,
we
have
to
switch
to
it
so
check
it
again.
A
A
A
A
A
A
So
we
check
this
is
p
e,
p,
e,
f,
okay,
so
and
that's
an
important
step.
So
maybe,
when
you
try
to
modify
some
things,
then
you
will
have
here
another
hash
value,
and
then
you
don't,
when
you
forget
to
change
this
hash
value
in
the
chain
code,
environment
file,
then
you
will,
you
will
do
everything,
but
the
chain
code
container,
the
chain
code,
container
chain
code
service
will
not
start
so
and
that's
an
that's
a
mistake.
A
I
have
seen
in
my
in
my
tests
sometimes
so
you
have
to
be
aware
of
this
and
you
have
to
be
carefully
with
this
chain
code
environment
file
that
this
this
hash
value
is
the
right
one
which
is
which
co,
which
is
the
same.
If
you
have
installed
here
on
there
on
the
ps-
and
you
say
this
chain
code-
query
installed
command
when
you
set
this
command
okay.
A
A
But
this
docker
file,
so
that's,
is
also
provided
in
the
in
the
very
examples
so
you
have
to
to
you
have
to
change
anything
nothing.
You
have
to
change
nothing
in
this,
so
the
only
thing
what
you
have
to
take
care
is
that
this
path.
This
is
the
same
path
for
your
train
code.
So
maybe
you
will
try
another
chain
code
yeah.
A
When
you
try
to
reproduce
this
example
with
another
chain
code,
then
you
have
to
adopt
here
the
path
that,
when
you
say,
fair
examples
and
in
the
fair
examples
you
have
another
subdirectory
with
your
test
chain
code.
Then
we
have
to
adjust
this
here
and
so,
but
that's
all
what
we
have
to
do
here
and
then
we
can
build
this
docker
image.
A
A
A
A
A
A
A
A
So
I
start
with
organization
two
and
yeah,
so
all
these
parameters
we
have
seen
in
the
last
session,
so
the
important
parts
here
are
make
sure
that
you
have
the
right
channel
name,
make
sure
you
have
to
write
the
train
code
name
and
the
right
version
and
be
carefully
with
the
sequence
number,
and
here
we
have
the
package,
the
package
id.
So
in
the
last
session
we
I
think
we
used
ccid
another
name
for
this,
but
it
doesn't
matter
what
is
the
name?
So
that's
an
environment
variable
with
this
value
here.
A
One
and
do
the
same
for
organization,
one
yeah
and
then
the
final
step
is
the
commit
step
so
that
when
and
when
we
have
them,
when
the
majority
of
the
of
the
network
members
have
approved
this,
then
we
can
commit
this
and
to
check
it.
We
can
use
the
check,
commit
variance
command,
and
you
see
here
the
approvals
here.
We
see
organization,
one
okay
and
organization.
A
A
A
A
And
now
we
can
query
this
and
you
see
you
will
have
the
first
result
and
if
this
takes
more
than
one
second,
then
you
know
something
is
wrong.
So
and
then
you
have
to
look
into
the
in
the
deluxe
to
see
and
to
find
maybe
an
error
and
to
see
the
logs
here.
So
you
can
do
it
very
easily
when
you
use
docker.
A
A
Yeah
so
with
this
command,
docker
compose
and
locks
and
follow-
and
this
is
you
can
say
on
which
which
position
you
will
see
the
log
files
and
with
this
command,
you
can
see
all
the
outputs
from
the
from
from
this
particular
docker
compose
file,
and
so
we
can
see
and
then
we
then
I
have
you
prepared
a
second
terminal.
So
today
I
don't
use
the
max
version,
so
I
used
a
second
terminal,
because
with
this
we
can
a
little
bit
easier.
Do
the
scrolling
here
and.
A
A
A
So,
and
to
check,
if
the
so
the
query,
the
query
works.
So,
as
we
have
seen,
and
now
we
can
use.
Also
one
transfer
function
to
invoke
something
so-
and
this
is
this
changes
the
the
owner
from
asset
one
to
roland
and
when
we
query
asset
one,
we
will
see
as
well
here
so
and
when
you
see
doc
appears,
you
see
here
only
this
asset
transfer
basic
container,
and
this
is
how
you
can
use
this
external
chain
code
service.
A
So
when,
as
soon
as
this
container
is
in
the
docker
network,
then
you
can
use
it
and
when
we
try
now
to
install
the
normal
way,
we
can
do
it
as
well.
So,
in
the
next
step
we
are
going
to
install
the
apps,
the
a
b
store
chain
code,
sn
normal
as
an
internal
train
code,
and
then
you
will
see
here
that
both
for
ps0
organization,
two
and
one
we
will
have
another
container,
the
these
typical
chain
code
containers
as
well,
and
to
install
this.
A
A
And
that's
the
reason
because
the
chaincode
container
will
be
built
now
in
the
background,
and
this
is
also
the
advantage
from
the
version
2,
because
when
when
we
commit
the
chain
code,
then
the
jenkot
container
is
ready
from
the
first
invoke
command
on
so,
and
that
was
the
difference.
The
difference
between
the
version,
one
point
with
the
version
one
because
then
only
on
the
first
inbox
command,
the
chaincode
container
was
built.
A
This
is,
I
can
say,
maybe
this
is
a
disadvantage
to
this
to
this
to
this
scenario,
and
but
maybe
I
don't
know
how
this
is
when,
when
you're
doing
this
in
the
kubernetes
cluster,
how
you
can
handle
this
single
point
of
failure.
But
this
is
true.
So
when
you
use
this,
we
have
a
single
container
and
we
can
try
it
when
this
chain
code,
the
second
transcript,
is
running.
A
A
A
I
think
it's
the
normal
way
and
also
the
gossip
protocol,
and
when
you
use
the
node.js
the
discovery
service,
they
will
know
which
which
beer
is
online
and
which
is
ready
and
will
then
create
query
peer,
p1
up
here,
0
or
pl
3
from
this
organization
to
to
get
the
data,
and
when
you
have
a
single
chaincode
container,
then
you
will
maybe
will
have
a
problem.
So
and
that's
what
I
have
said
at
the
at
the
beginning.
That's
that's
an
advanced
feature
and
you
must
take
care
on
this.
A
You
have
to
handle
the
situation
in
different
ways
and-
and
you
I
think
you
need
the
use
case
for
this
and
yeah
so
okay,
this
is
the
chain
code,
2,
okay
and
then
let
us
check
so
that's
clear
installed.
It's
only
some
copy
and
paste.
Now
so
and
that's
here
you
can
see.
We
have
now
two
chain
code
installed
with
the
back
the
basic
which
we
have
as
seen
as
external
external
one
and
then
here
the
app
store
in
the
traditional
way
so
copy.
This.
A
A
A
A
A
A
Is
any
additional
feature
using
films
instead
of
ferric?
So
I
don't
know
so:
mini
fabric
is
a
good
way
to
start
it's
a
so
it's
a
it's.
A
way
to
favorite
is
complicated
and
you
have
to
know
a
lot
to
to
use
it,
and
I
think
mini
favorite
is
a
good
way
to
to
start,
and
but
I
I
don't
know
how
many
favorite
can
handle
these
additional
features.
So,
but
I
think
mini
fabric
is
now
is
going
to
be
in
hyperledger
or
an
incubator
project.
Maybe
so
they
will
push
it.
A
So
this
is
definitely
a
good
way
for
the
for
the
mass,
so
favorite
want
mass
adoption
or
to
improve
the
mass
adoption,
and
the
mini
fabric
is
a
good
way
to
start.
But
let
me
be
honest,
I
think
that's
really
a
good
way,
but
if
you're
as
a
programmer
or
as
a
system
administrator
or
as
a
technical,
you
have
to
know
what
is
behind
the
curtain.
A
And
I
think
it's
really
important
to
understand
what
is
how
favorite
works,
and
that
leads
to
the
fact
that
you
have
to
spend
a
lot
of
time
and
to
learn
a
lot
that
you
can
build.
A
system
like
your
business
needs
and
I
haven't
spent
so
much
time
in
the
mini
fabric
project.
But
I
think
it's
a
it's
a
really
really
good
project
and
you
definitely
should
take
time
and
look
into
this.
A
A
So
what
dumber
here?
No,
I
don't
think
so.
So
that's
an
that's!
The
dominant
is
an
interesting,
interesting
topic
and
I
think
casey
10
has
an
awesome
article
written
to
this
topic,
and
you
should
go
into
this
and
read
read
about
this
and
but
in
in
in
the
upcoming
sessions.
We
I
think
we
don't
use
this.
Maybe
casey
will
make
an
in
session
for
us
and
then
we
can
ask
him
to
give
us
us
a
good
introduction
to
this.
A
In
one
of
the
session,
can
you
please
share
how
we
can
set
up
appear
to
run
chain
code
with
java
language
instead
of
go
yeah?
I
think
I
can
do
it,
so
I'm
not
a
java
man
so,
but
the
process
is
from
from
from
the
installation
part.
I
think
the
process
is
basically
the
same
so
and
that's
that
that
is
what
favorite
fabric
says
it
is
plug
and
play.
A
So
when
you
start
with
this,
you
say
plug
and
play
okay
that
sounds
easy
and
then
you
will
recognize
that
fabric
isn't
easy
and
what
they
mean
with
plug
and
play
and
that's
the
part
what
they
mean.
So
as
a
chain
code,
you
can
use
the
length
you
can
use
java
for
chain
code
as
a
train
code
and
you
can
use
node
shares
and
from
the
install
process.
A
I
think
there
is
no
difference
and
when
you
look
into
the
into
this
network
script,
then
we
have
a
parameter
where
we
can
say
which
language
will
be
installed,
and
then
you
can
say
that
this
nodejs
this
is
java
and
when
you,
when
you,
when
you
unuse
when
you're,
not
use
this
parameter,
then
it's
it
will
be
go.
So
I
think,
from
the
installation
process
from
the
improve
process.
A
That's
everything
the
same,
but
it
will
be,
of
course,
a
different
when
it
comes
to
how
you
write
the
chain
code
in
java
or
how
you
write
the
chain
coding
node
shares.
So
that
will
be
a
different
of
course,
because
the
implementation
is
a
little
bit
different
because
go
nodejs
and
java
doesn't
doesn't
interact
with
the
ledger
directly,
so
they
use
an
api
and
indigo.
A
We
use
the
shim
api
or
the
contract
api
so,
and
this
api
gave
us
some
methods
which
we
can
use
to
interact
with
the
with
the
ledger
and
with
this
tranquil
functions
we
can
do
some
things
and
that's
in
that
is
also
in
in
the
node.js
world
and
also
in
the
java
world
and
in
the
future.
I
think
other
languages
will
come
and
that
that
that
was
they
say.
Well,
that's
the
meaning
of
plug
and
play.
A
So
they
want
to
use
that
that
as
much
as
possible
languages
and
people
with
different
backgrounds
can
use
fabric-
and
that's
that's
the
that's
the
cool
thing
on
on
on
fabric
that
you
can
use
so
much
different
different
techniques.
But
yes,
it
is
that's
open
source
and
I
think,
with
the
go
language
with
gold
chain
code.
A
This
is
the
primary
the
primary
language
for
train
code
development
and
that's,
I
think
it's
the
best
maintained
so
and
and
no
cheers
and
java
are
also
good
maintained.
And
but
I
I
know
not
so
much
about
the
travel
world
in
this
in
this
in
this
thing,
but
the
installation
process
and
the
approved
process
is
the
same.
A
Maybe
we
can
we
can
do
the
decembers,
so
I
can
try.
If
I
can
do
this,
please
expect
spam
use
cases
yeah,
that's
a
good
question,
but
I
think
yeah.
So
that's
also
a
new
topic.
This
extensive
blockchain
object
model.
So
that's
definitely
a
an
interesting
part
and
I
have
to
say
I
have
to
mention
casey
again.
He
has
also
written
two
three
weeks
ago,
an
awesome
article
about
the
x-bomb
technique
and
yeah.
So
that's
an
interesting
part
where
we
can
use.
A
A
A
A
Okay,
so
yeah,
so
I
think
then
we
are
on
the
end
of
this
meetup.
So
the
last
thing,
maybe
you
should
do
it
by
your
own.
Here's
an
example
where
you
can
see
how
you
how
you
can
use
the
google
cloud
buildbacks-
and
this
is
also
here
in
the
repo.
So
I
think
that's
a
really
interesting
and
and
and
good
way
to
build
your
docker
containers
and,
as
you
can
see
here
when
you
clone
this
repo
here
from
the
google
cloud
platform,
then
you
have
different
examples
here.
A
A
Use
this
name
this
this
image
name
for
this,
and
then
you
will
receive
a
docker
image
and
that's
it.
So
I
think
that's
a
a
good
way
to
to
use
to
to
build
docker
images
and
that's
heavy
rebase
command
for
this.
So
I
think
that's
really
really
useful
when
you
work
with
docker
images
and
when
you
are
a
developer-
and
you
want
to
use
this-
we
have
to
use
this.
A
The
container
images-
and
here
is
an
option-
that's
the
same
when
you
do
it
with
heroku
and
because
big
bags
are
basically
founded
by
heroku
and
this
ide,
and
when
you
come
to
my
link
to
my
documentation
this-
and
you
will
see
how
you
can
build
this
and
to
understand.
So
I
think
that's
definitely
something
which
every
web
developer
should
look
into
and
yeah
that's
the
cool
thing
so,
as
I
have
mentioned,
and
that
should
be
also
my
final
words
here.
A
That
favorite
is
a
set
of
technology
from
cloud
technologies
which
works
in
an
awesome
way
together,
and
you
can
use
for
your
own
purpose
single
pieces
from
this,
like
this
cloud
builds
or
the
speed
bags
docker
as
well.
Docker
compose
as
well
and
so
on,
and
also
all
the
all
the
stuff
which
going
on
on
cryptography,
you
can
use
the
certified
authorities
and
so
on.
A
So
there
are
a
lot
of
techniques
which
you
can
use
in
your
normal
ig
life,
and
when
you
come
with
a
background
from
as
a
web
developer
as
a
developer
or
as
administrator,
then
you
will.
I
think
you
will
see
that
there
are
a
lot
of
technologies
you
are
used
and
but
you
have
to
think
it
and
you
bring
in
another
way
and
then
in
the
world
of
favorite.
You
can
combine
this
and
then
you
will
have
a
good
understanding
how
the
things
work
together.
A
Go
learning
yeah
goal
learning.
I
think
there
are
a
lot
of
good
resources.
Go
is
one
of
the
languages
I
think
like
node.js,
for
example,
which
could
be
really
really
good
learned
over
the
internet.
So
you
find
a
lot
of
useful
information
on
your
official
golang
site
and
then
you
can.
It
depends
on
you.
If
you
you
can
have
a
lot
of.
You
can
buy
a
lot
of
books
when
you
like
to
to
to
learn
from
books.
You
have
a
lot
of
video
tutorials.
A
You
can
have
a
lot
of
courses
on
ethics,
for
example,
of
course
era
and
so
on,
and
so
I
think
it
depends
a
little
bit
on
on
you
how
you
can
learn.
You
can
make
online
courses,
for
example
and
yeah,
so
I
think
to
learn.
Go
that's
that
you
will
have
too
much
resources
to
find,
but
I
think
you
you
have
to
find
out
what
is
the
best
fit
for
you
and
but
to
learn
a
language
like
go,
node
shares
or
whatever
the
the
simple
thing
is.
A
A
There
is
some
go
knowledge
important,
but
not
so
much.
I
think,
because
the
gold
chain
code
is
really
strict,
so
you
have
to.
There
is
a
schema
and
when
you
know
the
schema,
I
think
you
can
handle
a
lot
of
use
cases
with
go,
and
for
that
you
don't
have
to
be
a
very
experienced,
go
developer
because
a
chain
code
should
be
small.
A
So
you
have
to
be
make
sure
that
the
chain
code
is
small
and
clean
and
in
the
simplest
way
the
simplest
thinking
the
chain
code
is
is,
is
really
simple,
so
you
will
store
in
the
blockchain
a
key
and
the
value
and
some
techniques
are
important,
so
some
converting
techniques,
how
you
define
a
variable,
how
you
can
convert
the
string
in
the
byte
stream
and
something
like
that.
But
when
you
look
through
the
examples
for
the
favorite
examples-
and
they
are-
I
mean
for
every
use
case
for
every
chain
code.
A
A
You
have
seen
something
new
and
if
you
have
any
feedback,
please
send
me
an
email
or
write
it
down
in
the
slack
channel
on
the
meetup
page
or
you
can
contact
me
on
different
ways.
If
you
would
like
to
see
a
particular
topic,
then
you
can
also
give
me
this
information.
Then
I
will
I
will.
I
would
like
to
organize
this
and
the
points
about
the
demo.
Yeah
and
xbomb.
That's
definitely
a
good
one.