►
From YouTube: Hyperledger Fabric on Kubernetes using HLF Operator
Description
A virtual meetup hosted by the Hyperledger India Chapter on May 14, 2022 featuring Aditya Joshi, blockchain engineer at Walmart. This is a hands-on demo session where Aditya showcases how to setup a Hyperledger Fabric network on Kubernetes with the help of HLF operator (which is a project under Hyperledger labs). This supports Fabric version 2.4 and external chain codes also. The session will cover areas like CA setup, peers and orderer setup, channel creation and join process and chaincode operations.
More about Hyperledger Fabric is at: https://wiki.hyperledger.org/display/fabric/
More about the HLF Operator lab is at: https://github.com/hyperledger-labs/hlf-operator
----
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
Discord: https://discord.gg/rVCn4j7UFd
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 #Blockchain
License
Creative Commons Attribution license (reuse allowed)
A
All
right,
so
I
I'll
start
with
first
of
all,
welcome
and
a
thank
you
for
coming
in
here.
This
session
is
organized
by
hyperledger
hyderabad
and
we
are,
we
started
our
journey
from
2017
and
I'm
sure
you
know
a
lot
of
you
might
already
have
attended
a
lot
of
sessions.
We
are
43,
live
events
and
still
counting
one
of
the
largest
community,
at
least
in
india,
so
we
have
around
30
1300
plus
members
across
india
and
world,
and
we
are
also
you
know
available
on
whatsapp
group.
A
So
if
you
like
us
to
you
know,
add
you
to
that
group,
you
can
you
know
mail,
us,
the
email
ids
are
here
and
we'll
also
share
it
on
the
chat
later
and
if
you
like
to
you
know,
since
we
are
a
community
where
we
we
look
forward
to
learn
and
expand,
so
in
case
you
want
to
be
the
next
presenter
you're
most
welcome.
You
can
reach
out
to
me
or
karthikey.
A
We
both
bullied
this
chapter
and
I
can't
you
know,
stop
talking
how,
without
saying
a
word
of
thanks
to
vikram
and
kamlesh,
who
had
been
extremely
supportive
of
arranging
these
discussions,
and
you
know
helping
us
everywhere
because
of
them.
We
are
able
to
present
this
time
as
well.
Now,
I'm
just
stopping
my
screen
and
quickly
want
to
introduce
aditya,
I'm
sure
a
lot
of
you
might
already
be
seeing
the
kind
of
work
he's
doing
in
the
community.
A
A
B
Yeah,
thank
you.
So
the
topic
for
today's
meetup
is
is
going
to
be
towards
running
high,
clear
fabric
network
on
kubernetes,
and
this
time
we
are
using
a
tool
called
hlf
operator,
and
probably
I
will
give
more
context
about
this
tool
like
what
this
tool
does
and
why
this
tool
was
actually
created
to
solve
some
of
the
specific
use
cases.
So
before
that,
like
I
would
like
to
introduce
myself
so
I
am
aditya
and
currently
working
as
a
blockchain
engineer
at
walmart.
B
I
am
also
a
certified
hybrid
fabric
administrator
and
a
cubanites
developer
as
well,
and
apart
from
that,
like
I
am
also
instructor
at
udemy,
so
I
have
published
a
couple
of
courses
around
the
udemy
in
in
the
space
of
blockchain
and
kubernetes.
I'm
also
the
maintenance,
hlf
hyper
hyped
labs
project,
this
hlf
operator
project.
B
So,
let's
discuss
about
like
what
hlf
operator
is
and
probably
then
we
will
discuss
like
why
this
of
this
operator
was
created.
So
we
all
know
that
kubernetes
and
hybrid
fabric-
they
both
are
completely
distributed.
Systems
and
probably
managing
these
two
distributed
systems
under
one
roof,
becomes
very,
very
much
complicated
when
you
have
two
different
distributed
system,
they
both
are
kind
of
standalone,
and
you
have
to
bring
these
kind
of
system
under
one
roof
then
becomes
very,
very
much
challenging.
B
This
project
is
currently
under
hyped
lab
so
recently,
last
month
only
we
migrated
this
project
under
hybrid
labs
and
all
the
operations
that
we
are
going
to
see
in
today's
demo
or
whether
you
are
going
to
set
up
it
on
your
own
as
well.
We
will
be
using
a
cube,
ctlhf
plugin
that
comes
along
with
this
operator
and
all
the
commands
and
all
the
operations
that
you
will
see.
B
They
will
be
through
this
cubectl
hl
plugin,
so
I
just
want
to
throw
some
light
like
why
this
operator
was
created,
so
we
have
already
couple
of
solutions
available
in
the
open
source
market
like
we
have
bevel.
We
have
argo
based
hem
chart
and
we
have
couple
of
other
open
source
projects
as
well
around
it.
So
this
operator
is
solving
some
of
the
specific
use
cases.
B
Let's
say
there
are
some
organization
which
all
you
know,
communities,
but
they
are
not
pretty
much
familiar
with
the
fabric
or
ways
to
deploy
it
and
in
the
in
the
organization
they
are
pretty
much
dealing
with
the
humanities,
manifest
those
gml
files,
so
this
operator
provides
a
declarative
way
of
creating
those
components.
So
pretty
much
here
as
well,
you
are
dealing
with
those
gml
files
and-
or
you
are
just
writing-
those
declarative
commands
and
the
pretty
much
the
components
are
created
for
you
like
peers
or
ordering
service
channels.
B
All
those
are
created
with
just
the
help
of
one
command.
It
provides
an
abstraction
from
the
initial
bootstrapping
of
the
nodes.
So
probably,
if
you
have
tried
to
set
up
this
network
on
your
local
machine
with
the
help
of
fabrics
sample
examples,
if
you
have
tried
to
run
the
test
network,
you
might
have
seen
a
lot
of
things
go
when
you
run
those
script,
starting
from
generating
those
certificates,
then
creating
the
genesis
block
and
then
joining
the
channel.
B
So
pretty
much
a
lot
of
thing
goes
there,
but
this
provides
a
lot
of
abstraction
and
pretty
much.
The
commands
are
very
straightforward
and
imperative.
So
you
just
hit
a
command.
Let's
say
you
want
to
create
a
channel
you
just
fire
that
command
a
channel
is
created
for
you,
so
you
don't
have
to
do
a
lot
of
initial
bootstrapping
for
you
this.
This
is
done
by
the
operator
itself.
B
This
is
based
on
kubernetes,
so
this
can
pretty
much
work
on
any
kubernetes
environment,
whether
it
is
on
on-prem
or
cloud.
So
all
you
need
is
a
community
structure
and
you
are
pretty
much
good
to
go.
This
is
highly
customizable
and
in
terms
of
customizability
you
can
customize
it
for
specific
use
cases.
Let's
say
you
want
to
renew
certificates
every
year
or
within
every
six
month
you
can
customize
it
or
you
want
to
increase
the
storage
that
your
peers
or
ca
servers
or
ordering
nodes
are
using.
B
You
can
pretty
much
do
it
and
also,
if
you
have
any
specific
use
case
around
it,
you
can
pretty
much
customize,
the
plugin
and
the
operator,
so
that
is
very
straightforward.
Underneath
hood,
it
is
using
the
operator
sdk
from
the.
I
think
that
is
from
the
red
hat.
So
pretty
much.
You
are
interacting
with
the
kubernetes
operator
and
then
it
creates
components
for
you.
B
So
now
I
would
like
to
discuss
the
basic
functionality
of
a
kubernetes
operator
and
then
probably
we
will
see
a
high
level
component
diagram
of
this
hlf
operator.
So
on
the
left
side
we
have
a
user
and
user
is
pretty
much
interacting
with
the
custom
resources
and
the
custom
resources
comes
along
with
the
operator.
So
when
you
install
the
operator,
custom
resources
are
created
for
you.
Basically,
the
custom
resources
definitions
are
created
for
you
and
you
create
custom
resources
using
those
definitions
and
in
of
this,
the
custom
resources
are
peers.
B
Orders,
certificate
authorities
and
chain
codes,
and
we
have
an
operator
so
operator,
is
nothing
just
a
go
program
that
is
running
on
your
communities,
cluster
and
it
has
a
reconciliation
group
that
runs
within
the
operator.
So
what
it
does
is
it's,
it
basically
subscribes
or
tracks
the
events
in
the
custom
resources
and
whatever
even
change
it
receives.
It
basically
try
to
take
decisions
on
those
events.
So
let's
say
any
investors
try
to
match
your
desired
state
with
the
current
state
of
communities
cluster.
B
So
what
I
mean
by
this
desired
state
and
current
state.
So
let's
say
you
define
a
custom
resource
and
you
want
to
have
let's
say
two
peers
and
somehow
your
network
has
only
one
pair.
Maybe
it
is
failing
or
it
doesn't,
it
doesn't
have
like.
The
community
cluster
does
not
have
enough
resources
in
terms
of
memory,
cpu
or
maybe
disk,
then
maybe
it
may
be
it.
It
could
be
a
pending
state
as
well,
so
this
operator
is,
it
will
try
to
match
your
current
state
and
your
desired
state.
B
B
So
this
was
the
high
level
overview
of
how
operator
works,
and
this
is
this
applicable
to
any
kind
of
operator
not
actually
operator.
This
working
of
any
kind
of
operator
so
operator
basically
tracks
the
custom
resources
that
you
create
and
they
subscribe
to
the
events
and
they
take
necessary
decisions
according
to
those
events
and
try
to
maintain
to
your
desired
state.
With
the
current
state
of
your
cluster.
B
So,
on
the
right
side,
you
can
see
we
have
a
user
machine
component
and
basically
this
could
be.
This
machine
is
referencing
here,
a
user
who
is
trying
to
interact
with
the
cluster
or
trying
to
interact
with
the
operator.
So
it
could,
like
the
user,
can
interact
with
the
cluster
either
using
the
cube,
ctl
http
plugin
that
we
will
see
in
today's
demo
or
using
the
kubernetes
api.
B
B
We
have
a
library,
so
libraries
are
available
pretty
much
in
all
the
popular
languages,
so
you
can
either
use
those
apis
or
you
can
use
this
cube,
ctl,
hlf,
plugin
and
just
to
give
you
a
context,
this
cube,
ctel,
hdf
plugin,
is
also
built
over
client
go
library
which
provides
your
way
to
interact
with
the
with
the
cluster
so
in
near
future.
If
you
wish
to
like
you,
don't
want
to
use
this
cubesat
plugin,
you
are
free
to
you
go
like
underneath.
B
B
Yeah
so
yeah,
so
just
to
summarize
this
slide,
so
basically
we
you
can
have
either
a
cube,
ctl,
hdf,
plugin
or
you
can
use
client,
libraries
or
apis
to
interact
with
the
communities
tester,
and
you
can
write
your
own
application
out
of
it
like
for
this
project.
For
this
operator
we
wrote
this
cube
cityless
plugin,
and
it
is
basically
a
client
it
is
in.
It
is
a
layer
over
client2
library,
and
we
are
using
this
to
interact
with
the
cluster.
So
pretty
much.
B
So
now
I
would
like
to
discuss
some
of
the
features
of
this
operator,
so
it
helps
you
in
creating
the
certificate
authorities.
So
you
don't
need
to
manage
anything
pretty
much
like
you
all
you
would
be
dealing
is
you
would
be
mostly
registering
the
identities
and
enrolling
the
ionitis,
so
managing
of
the
circulator
thought
is
done
by
the
operator
it.
The
same
is
done
for
the
peers
and
ordering
surveys
as
well,
so
ordering
service
creation
or
peers
creation.
B
Those
are
done
by
the
operator
for
you,
you
just
fire
a
command
and
it
will
provision
those
resources
for
you
and
you
don't
have
to
manually,
go
and
provision
the
cryptographic
materials.
So,
with
the
help
of
just
com,
a
single
command,
you
can
provision
the
crypto
material
like
the
certificate
or
any
artifact
you
need,
you
can
create
them,
and
you
don't
have
to
do
a
lot
of
setup
before
that
and
operator
also
supports
domain
routing
with
the
help
of
stu.
B
It
also
supports
certificate
renewal
as
well,
so
you
have
to
just
run
a
command
and
it
will
renew
the
certificate
for
you
and
it
works
pretty
much
well
for
the
peer
certificate.
But
when
you
are
updating,
when
you
are
reading
the
order
certificate,
there
is
some
manual
intervention
that
you
have
to
do.
Yeah
and
also.
I
just
like
to
add
one
more
point
here
that
this
operator
is
in
the
operator.
We
are
using
the
channel
participation
api.
A
B
Okay,
so
it
does
not
support
1.4,
we
started
with
version
2
and
in
future
as
well.
We
don't
have
any
plan
of
supporting
version
1.4,
because
things
were
things
are
like
pretty
much
different
in
1.4,
so
the
idea
is
to
like
we
started
this
with
version
two,
and
we
will
like
scale
it
like
whatever
fabric
or
latest
fabric
version,
we
will
get
maybe
2.5
or
version
three.
We
will
continue
on
on
the
forward
approach.
A
B
Okay,
yeah
pretty
much
interesting
question
and
this
I
think
this
is
a
valid
use
case
question.
So
this
operator
is
not
is
not
designed
to
handle
those
use
cases
this
operator
is
is
focusing
or
the
idea
of
having
this
operator
is
to
focus
only
on
the
on
the
on
the
cube
on
the
hypothetical
fabric
part
and
these
the
backup
and
the
recovery.
B
They
are
pretty
much
out
of
the
scope
of
this
operator,
but
if
you
want
to
set
up
backup
and
recovery,
they
are
pretty
much
some
solutions
available
in
the
open
source
and
in
the
some
some
paid
solutions
as
well
like
you
can
use
valero,
and
I
I
have.
I
have
pretty
much
tried
valero
for
backing
up
the
this
fabric
cluster
using
this
operator,
and
it
worked
pretty
much
well.
B
So
I
have
like
tried
valero
and
I
did
a
backup
and
basically
I
did
a
cloud,
a
cloud
migration.
So
in
that
case
my
cluster
was
running
in
sub
cloud.
A
and
I
migrate
that
to
cloud
b
with
the
help
of
valero.
That
is
open,
source
solution,
and
you
have
a
couple
of
paid
solutions
as
like.
I
think
there
is
one
solution
called
casting,
so
you
can
use
those
as
but
they
come
with
some
cost.
B
So
the
idea
is
so
this
the
whole
intention
of
having
this
operator.
We
just
want
to
focus
on
the
on
the
on
the
hlf
part,
not
on
the
backup
and
recovery.
Maybe
in
future
we
can
think
of
this,
but
backup
and
recovery
is
is
a
pretty
vast
topic
and
I
think
that
is
very,
very
much
early
for
this
operator
to
incorporate
it.
A
B
So
let
me
just
answer
this
one
more
question:
I
see
in
the
chat,
so
yes,
yes,
it
does
support
unjoining
of
peers
and
channels,
because
we
are
using
the
channel
participation,
api
and
channel
participation.
Api
works
in
the
joining
and
enjoying
part.
So,
yes,
it
supports
that
feature,
and
this
feature
was
not
available
in
the
I
think
the
prior
version
of
fabric
but
with
and
if
you
are
using
channel
participation
api
only
then
you
can
use
that
join
and
join
feature.
B
B
So,
obviously,
you
need
a
community
structure
where
you
will
be
running
this
operator,
then
you
need
a
cube,
ctl
command
line.
So
this
is
the
command
line
using
which
you
interact
with
your
communities.
Cluster.
You
need
a
help,
so
helm
is
basically
a
package
manager
that
helps
you
in
installing
various
helm
charts.
It
is
similar
to
what
you
have
in
in
node.js.
B
B
Second
namespace
is
going
to
be
the
fabric
namespace
and
in
the
first
namespace,
which
is
a
default
namespace
there.
I
am
planning
to
have
the
hlf
operator
and
my
operator
is
going
to
reside
on
this
namespace
in
the
fabric
namespace.
I
will
have
all
my
organization
whether
it
is
a
peer
organization
or
an
ordering
organization,
so
I
will
have
two
or
two
peer
organization:
organ
and
octo,
and
one
order
organization
and
inside
the
peer
organization.
B
B
B
B
B
We
will
be
deploying
the
chain
code,
which
is
my
cc,
and
this
will
be
an
external
chain
code
and
for
this
demonstration
I
have
specially
prepared
the
node.js
part
like
we
will
be
going
to
see
the
node.js
chain
code,
and
I
will
come
to
this
in
the
later
part
like
why
I
chose
node.js
only
for
the
chain
code,
part
yeah.
So
now
I
will
share
my
terminal
window
and
probably
from
there
we
can
take
it
forward.
B
So
before
that,
I
would
like
to
show
you
that
I
have
already
created
a
cumulative
structure
on
the
digital
ocean,
because
that
was
the
fastest
way
for
me
to
create
a
cumulative
structure,
and
this
is
a
two
node
cubitius
cluster
and
let
me
just
download
the
tube
config
so
that
I
can
interact
with
the
cumulative
tester
yeah.
It
is
done
now.
Let
me
just
move
to
terminal
and
hope.
My
terminal
is
visible
to
you,
like
the
font.
Size
is
visible
to
you
all.
A
B
Yeah,
so
I
am
in
one
directory,
I
have
already
get
this
directory
and
this
is
hfk8
and
pretty
much.
This
directory
has
just
one
folder.
If
I
show
you
this
is
the
fab
card
folder,
and
this
is
a
chain
code
part.
I
will
come
to
this
folder
later
when
we
are
actually
dealing
up
with
the
chain
code.
But
apart
from
this,
I
have
nothing
in
this
folder
and
first
thing
what
I'll
do
is.
I
will
basically
set
up
my
cube
ctl
so
that
I
am
able
to
connect
to
my
community.
B
B
Yeah,
so
it
got
exported
now,
let's
see
if
we
can
connect
with
the
human
rights
cluster.
So
let
me
just
run
this
command.
Cpl,
get
notes
just
to
make
sure
that
we
are
connected
to
the
cluster
yeah.
So
you
can
see
we
are
printed
to
this
cluster
and
I
have
two
nodes
up
and
running
in
this
cluster
now.
B
B
B
So
using
this
command,
which
is
helm,
install
hlf
operator
and
where
we're
specifying
the
version
that
we
want
to
install-
and
this
is
the
chart-
so
let
me
just
run
this,
so
this
is
going
to
create
a
operator
in
the
default
namespace.
And
if
you
want
to
install
this
operator
in
a
different
namespace,
you
can
pass
hyphen
iphone
in
space
flag
and
pass
your
namespace.
B
B
B
Machines,
it
is
already
installed,
but
if
it
is
not
available
in
your
machine
it
will
get
installed.
Okay,
so
now
I
think
our
operator
is
up
and
running.
Let's
verify
this,
so
the
operator
is
up
and
running
now.
What
we
have
to
do
is
we
will
first
try
to
grab
the
environment
or
the
storage
class,
because
this
operator
needs
a
storage
class
when
it
is
provisioning.
Those
resources
for
you.
B
So
let's
it
should
like
the
operator
needs
that
knowledge
that,
on
which
storage
class,
we
want
to
create
the
persistent
volumes
for
those
peers
or
storage
for
order
or
ce.
So,
let's
see
what
all
storage
class
we
have,
so
we
have
only
one
storage
class,
which
is
do
block
storage
and
it
depends
on
the
type
of
cluster
you
are
using
the
cloud
provider
you
are
using
and
let
me
just
run
this
command,
so
this
is
going
to
get
the
storage
class
and
set
it
into
one
environment
variable
with
name
sc.
B
B
Yes,
so
this
is
the
command
which
will
create
the
ca.
Let
me
just
make
you
walk
through
this
command,
so
this
is
the
plugin
that
we
installed
with
the
help
of
crew,
and
here
we
are
specifying
that
we
need
to
create
a
c
where
we're
specifying
the
storage
class.
So
if
your
qubit
is
multiple
source
class,
you
can
pass
the
appropriate
storage
class.
B
As
per
your
requirement
and
remember
you,
we
just
set
the
value
of
this
variable
in
the
last
command
and
then
we
are
specifying
the
capacity
that
how
much
capacity
this
ca
will
get
when
it
is
actually
bootstrapped
the
name
of
the
ca.
So
if
I'm
going
to
give
the
name
to
this
year's
august
here,
then
I'm
going
to
give
the
initial
or
the
bootstrap
identity.
B
So
if
you
remember,
when
you
actually
start
the
nec
or
ca
in
the
in
your
local
docker
network
as
well
using
fabric
samples,
you
see
that
the
initial
bootstrap
identities
passed
or
required.
So
this
is
the
same
identity
and
then
we
are
specifying
the
password
of
it,
and
then
we
specify
the
namespace
over
which
we
want
to
create
this
ca.
B
B
B
Yes,
so
you
can
see
that
they
are
still
in
creation
phase,
because
the
operator
is
trying
to
provision
the
persistent
volume,
basically
underneath
storage
for
them,
and
we
can
check
those
storage
as
well.
If
I
do
cube,
ctl
get
pv
in
the
like,
let's
do
all
name
spaces,
so
you
can
see
it
is
basically
a
provision.
B
It
has
provision.
These
persistent
volumes
for
those
cas,
so
you
can
see
ordered
ca,
is
bounded
to
this
percent
volume,
or
one
is
bounded
to
this
position.
Volume
and
or
oc2
is
bounded
to
this
persistent
point,
and
these
are
the
stories
that
we
specified
in
the
command
as
well,
and
this
is
the
storage
class
just
to
confirm.
B
Let's
see
if
the
pl
the
cas
are
up
or
not
yeah,
so
you
can
see
csr
okay,
so
now
we
are
done
with
the
ca
part
like
the
ca
setup
part
is
that
that
we
have
to
issue
certificates
for
the
components
and
then
that
will
see
in
couple
of
minutes
now.
Let
me
explore
some
in
my
variable
and
these
environment.
Basically,
these
variables
are
referencing
to
the
peer
image
that
you
want
to
use
in
their
version.
B
B
With
it
right
now,
okay
carry
on
with
your
flow
okay,
okay,
so
now
we
are
done
with
the
ca
creation
part,
but
we
need
to
have
the
identities
like
peer
and
a
tv.
So
whenever
in
fabric,
you
know
that
everything
is
permissioned
and
you
need
to
have
certificates
to
access
those
those
resources,
so
let's
create
an
identity
for
the
peer,
and
if
you
see
this
command,
this
is
here
we
are
registering
up
here,
and
here
we
are
specifying
the
name
of
the
ce
which
is
going
to
issue.
B
B
B
So
this
is
the
command
which
is
going
to
create
appear
for
us,
and
here
we
are
specifying
the
enrollment
id
identity,
the
one
that
we
just
register
the
msp,
and
then
we
are
specifying
the
peer
password
and
the
capacity
for
that
p.
Here
then,
we
have
space
also
specifying
the
peer
name,
and
then
we
are
specifying
the
ca
against
which
we
got
this
identity
and
one
more
thing.
B
So
here
we
are
specifying
the
state
databases
cause
database.
The
default
value
for
this
is
level
db,
but
if
you're
not
specific,
then
it
will.
It
will
take
the
default
value
as
level
db,
but
you
specify
this
as
the
couchdb,
then
it
is
going
to
create
a
couchdb
container
as
well.
Here
we
are
specifying
the
peer
image
action.
These
are
the
same
environment,
variable
that
we
just
exported
a
few
minutes
back.
B
B
B
B
So
far
we
have
covered
the
ca
part.
We
did
the
ca
setup,
we
did
the
peer
setup
and
now,
let's
try
to
create
the
I
admin
entity
so
that
we
can
actually
make
use
make.
We
can
actually
try
and
do
some
transactions.
It
could
be
joining
the
channel
or
it
could
be
installing
the
chain
for
all
those
transactions.
We
can
do
with
the
help
of
that
admin,
identity.
B
So,
first
we
will
register
entity
and
then
we
will
enroll
that
identity.
So
this
is
the
command
to
register
the
entity.
So
we
are
basically
registering
an
entity
against
this
ca,
so
we
will
get
the
identity
from
the
r1ca.
This
is
the
username
for
the
identity.
This
is
the
admin
password
and
the
type
of
identity
that
we
want
to
create.
So
we
are
going
to
create
a
admin
entity
and
remember
when
we
were
when
we
actually
created
the
identity
for
the
peers.
At
the
time
we
used
peer
as
the
type.
B
This
is
the
enrollment
details
of
the
ca,
and
then
we
are
specifying
the
msp
against
which
this
identities
are
going
to
be
issued.
So
this
is
going
to
register
that
identity
in
with
r1c
and
now,
once
we
have
done
the
registration,
we
can
actually
enroll
it.
So
in
enrollment
we
basically
get
the
certificates
of
that
identity,
so
I
will
show
you
like
how
we
are
actually
getting
at
the
circuit
and
how
we
are
going
to
use
those
certificates.
B
So
using
this
command,
which
is
hlfcn
role,
we
are
enrolling
the
identity,
and
here
we
are
passing
pretty
much
the
same
details.
There
is
one
difference
in
this
command,
which
is
ca,
name
and
just
one
thing.
I
just
want
to
add
here
that
when
we
actually
create
the
ca
internally,
the
operator
create
two
kind
of
c:
is
there,
so
it
creates
a
signing,
ca
or
and
the
second
one
as
a
tlscm.
So
here
we
are
going
to
get
the
signing
certificate.
B
So
that's
why
I
specified
the
ca
here
and
in
the
order
section,
you
will
see
that
we
will
actually
do
the
enrollment
for
both
for
the
signing
certificate
and
for
the
tls
certificates
as
well,
and
this
is
the
output
file
where
our
certificate
are
going
to
be
stored
in
our
local
machine.
These
are
the
msp
details
and
the
name
space
over
which
we
have
the
components
and
if
I
do
and
like,
if
I'll
do
ls
here,
probably
you
should
see
one
or
one
hyphen
p
here,
file.
B
B
Now
let
me
do
the
same
thing
for
the
octo
as
well
like.
Let
me
try
to
get
this
resistance
and
identity
like
the
tradition
and
the
unknown
part
for
the
admin
entity,
but
this
time
for
the
octo,
so
I'm
pretty
much
running
both
the
commands.
At
the
same
time,
the
first
command
is
the
registration
command.
B
Okay,
so
now
we
are
pretty
much
done
with
this
part.
Now
we
can
do
the
ordered
setup
and
just
like
we
did
for
the
pier.
So
in
order
as
well,
we
have
to
first
register
the
order
identity
and
then
we
can
create
the
ordering
node.
So
the
same
kind
of
thing
we
did
in
the
peer
as
well
like
we
first
registered
the
peer
so
that
we
have
the
certificate
for
that,
and
then
we
actually
created
the
peer
nodes.
B
So
using
this
command
we
can
register
an
order
and
this
is
the
same
command.
What
we
did
for
the
peers.
Just
a
couple
of
things
are
changed
here,
like
the
order
name
change
got
changed,
the
user
got
named
change
the
secret,
obviously,
and
the
type
of
identity
got
changed.
So
remember.
I
was
telling
you
that
we
have
four
kind
of
inequities,
so
peer
order,
admin
and
client,
and
then
we
are
passing
the
enrollment
certificate
and
then
we
are
passing
the
order,
msp
and
then
obviously
the
namespace.
B
So
here
using
this
command,
we
are
actually
going
to
create
an
order,
and
here
we
are
specifying
the
storage
class.
We
are
specifying
the
order
id,
and
this
is
the
same
id
that
we
use
in
the
very
last
command
which
for
which
we
did
the
registration,
the
msp
details
and
the
enrollment
password
and
the
capacity
for
this
order.
So
you
can
customize
all
these
parameters
as
per
your
requirement.
Let's
say
you
feel
that
2gb
is
not
enough
for
you
use
case.
Probably
you
can
try
to
increase
it
to
5gb
or
10gb
of
storage.
B
B
Yeah,
so
the
ordering
service
got
created,
let's
do
get
parts
and
see
if
this
order
is
getting
graded
or
not
yeah,
so
we
can
see
it
is
it
is
creating,
and
meanwhile
we
can
move
to
the
next
step,
which
is
we
have
to
get
the
order
admin
as
well.
So
in
the
previous
commands,
we
we
did
the
we
we
tried
to
register
admin
entity
for
both
the
organization,
but
now
we
have
to
do
this
thing.
The
same
thing
for
the
ordering
as
well
for
the
order
organization
as
well.
A
B
Me
just
clear
up
this,
and
now
we
can
register
an
admin,
so
this
is
the
same
command
this.
This
is
pretty
much
same.
What
we
did
for
the
organization
admin
like
augmen
admin
or
admin,
just
the
names
are
getting
changed
like
the
parameters
are
going
to
be
changed
this
that
we
are
getting
the
identity
from
ordered
ca,
then
the
msp
id
is
also
changed,
but
rest
of
the
things
are
same.
B
B
Is
I'm
passing
the
name
as
ca,
because
in
this
command
we
are
going
to
get
the
signing
certificates
and
the
output
or
the
the
certificates
are
stored
in
this
file,
ordering
service
dot,
email
admin
or
this
service
dot
ml?
So
let
me
run
this
and
once
if
I
do
ls
here,
you
should
be
able
to
see
admin
ordering
service,
dot
ml
file.
B
B
So
this
time
we
are
just
trying
to
get
that
the
circuit,
so
we
passed
the
cname
as
tlse
and
in
the
previous
command
we
were
trying
to
get
signing
certificates
and
the
output
is
going
to
be
stored
in
some
different
file.
So
the
output
is
going
to
be
stored
in
admin,
hyphen,
tls,
hyphen,
orderingservice.com.
B
So
if
I
do
ls,
you
can
see
we
have
the
admin
tls
ordering
service
okay.
So
now,
once
we
are
done
with
this,
we
can
just
quickly
get
grab
the
connection
profile
so
that
we
can
interact
with
the
network.
So
this
is
the
command,
and
here
you
are
here.
We
specify
the
organization
which
we
want
to
make
the
part
of
connection
profile,
so
only
these
organization
will
be
there
in
our
connection
profile.
B
B
B
So
this
is
the
vs.
This
is
my
vs
code,
and
this
is
the
network
connection
profile
that
we
have
here,
and
you
can
see
that
in
the
in
the
origin
section
we
have
a
user's
property,
but
right
now
this
is
empty.
So
we
are
basically
going
to
populate
this.
This
field
from
the
from
these,
these
admin
certificates
that
we
create
in
the
commands.
B
So
for
that
we
have
the
com.
We
have
one
command
there
in
the
cube,
ctl
plugin
as
well-
and
you
can
either
do
this
this
thing
manually
or
you
can
use
the
command
line.
So
let
me
clear
up
this
and
let
me
try
to
run
that
command,
so
this
is
basically
going
to
add
the
this
file,
which
was
having
the
admin
entity
for
the
augment
into
this
network
config
under
the
name
admin
and
for
this
msp.
What
I
meant
with
this
command
is,
let
me
show
you.
B
B
B
B
So
this
is
the
command
which
is
going
to
create
a
channel
with
name
with
output.
As
my
block,
my
channel.blog
and
the
name
of
the
channel
is
my
channel,
and
these
are
the
organizations
which
are
going
to
be
part
of
the
channel.
So
remember
if
you
have
ever
tried
to
set
up
a
a
network
on
your
local
machine,
you
use
a
configtx.cml
file
and
then
you
specify
all
the
members
who
are
the
part
of
the
channel
or
the
consortium.
B
B
So
the
channel
got
created
and
we
should
have
one
my
channel
dot
block
file
here
as
well.
This
file,
you
can
see
now
we
can
make
our
order
to
join
this
channel
and
remember
when
we
register
when
we
registered
the
admin
entity
for
the
for
the
for
the
order,
we
basically
did
the
two
kind
of
enrollment
there.
First
one
was
for
the
ca,
the
normal
signing
identity
and
second
one
was
the
tls
tls
certificate,
as
well,
so
in
this
command
the
next
command
that
I
am
going
to
run.
B
B
B
Yeah,
so
you
can
see,
we
have
some
blocks
here
and
you
can
see
it
joined
the
channel.
My
channel
and
the
con
center
is
one
like
why
we
got
the
concentra
as
one,
because
we
have
only
one
ordering
node
and
you
can
see
the
order
has
started
in
the
raft
mode
as
well,
and
it
has
pretty
much
like
started
listening
to
on
my
channel
now.
I
can
clear
this.
B
So
the
command
is
this,
so
we
are
basically
joining
up
the
channel.
We
have
to
pass
the
shell
name.
We
have
to
specify
the
network
config,
we
specify
we
have
to
specify
the
user
who
is
actually
going
to
perform
this
activity.
So
in
our
case,
that
is
the
administrator
that
we
just
added
in
the
network
config
and
the
peer
the
target
peer
which
is
going
to
join
the
channel.
B
So
this
should
like
our
org
one,
pier
one
should
join
the
channel,
so
it
has
joined
the
channel,
and
now
I
am
going
to
run
the
same
command
for
remaining
three
pairs.
Let
me
run
the
command
in
one
go
so
now
all
the
three
peers
are
remaining.
Players
are
going
to
join
the
channel,
so
r1
pa2
is
also
going
to
join
channel
or
pr1,
and
octop2
is
also
going
to
join
the
channel.
B
Maybe
if
we
have
the
time
then
we
can
see
so
now
we
have
so
now
so
far
what
we
have
the
ca
we
have
done.
The
peer
part
like
we
are
starting
the
peer.
We
have
done
the
ordering
part
as
well.
We
get
the
ordering
service.
Then
we
did.
The
channel
creation.
Part
channel
join
part
is
also
done
and
now
the
next
step
is,
we
have
to
add
our
peers
as
anchor
here.
B
Okay.
Okay,
let
me
show
you
again
so
now,
can
you
see
yeah?
It
is
visible.
Now
it
is
so
this
okay,
okay.
So
this
is
the
diagram
that
I
was
talking
about.
So
we
have
org
one
year,
one
and
octopia2
they
will
be
acting
as
anchor
peer
in
our
network
and
so
far
our
all
of
our
peers
has
joined
the
channel
and
but
now
the
next
part
we
are
going
to
do.
B
B
Yeah
so
both
of
them
has
joined
the
like,
they
are
they're
already
part
of
shell,
but
now
they
are
anchored
here
as
well.
So
now
we
are
done
with
the
anchor
ps
setup
as
well.
Now
we
can
do
the
chain
code
setup
and
we
are
doing.
We
are
setting
up
the
chain
code
as
external
gene
code.
So
probably
the
steps
that
you
see
might
be
different,
but
if
you
have
done
the
external
gene
code
setup
any
time
in
the
past
you
you
can
recognize
those
steps.
B
B
Yeah,
so
let
me
clear
this-
and
here
you
should
see
this
meta
data.js,
and
this
is
nothing
just
a
environment
variable
that
we
exported
the
mycc.
This
is
just
a
simple,
two-line
json
file.
Now
we
have
to
create
a
connection,
dot
json
as
well,
that
will
hold
our
chain
code
address
or
the
chain
code
service
address
that
peers
are
going
to
use
to
connect
to
this
chain
code.
B
B
When
they
are
actually
installing
the
chain
code,
the
first
thing
that
we
will
do
just
that
connection,
dot
json
file
and
put
it
in
into
this
code.z
file.
So
it
is
going
to
basically
archive
this
file
and
create
a
code,
dot,
r
dot
z.
As
output.
You
can
see
here,
we
should
have
this
file,
which
is
code.z
now.
B
What
we
have
to
do
is
we
have
to
basically
run
a
tar
command
again,
but
this
we
take
this
metadata.json
and,
along
with
this,
we
have
to
take
this
code.json
and
put
all
these
these
two
files
into
one
file,
and
I
will
call
it
as
my
my
channel
external
tar
dot.
So
basically
that
is
an
archive,
and
this
is
the
standard
process
that
we
do
with
the
external
chain
code.
So
nothing
fancy
here
and
if
I
show
you,
we
should
have
one
my
cc
external
dot
tz.
B
So
this
is
this
is
coming
from
the
plugin
itself.
So
here
we
are
using
the
calculate
package.
Id
function
that
is
available
in
the
in
the
plugin
and
we
are
specifying
our
chain
code
name,
we
are
specifying
the
language,
so
I
told
you
that
initially
that
I
am
going
to
use
the
node.js
as
the
language
for
my
chain
code
and
then
we
are
specifying
the
label
or
your
input
name.
B
B
The
archive
that
we
just
created
this
one,
my
my
channel,
hyphen
external
dot-
is
that
so
we
have
to
install
this
so
for
the
demo
I
am
going
to
install
only
in
the
one
one
peer
of
each
of
both
our
nation,
so
this
is
going
to
install
the
this
archive
here.
I'm
giving
the
path
the
network
config
file
and
the
language
is
the
chain
code
label.
This
is
the
user
who
is
going
to
make
the
transaction
and
the
target
peer
over
which
I
want
to
install
this
chain
code.
B
But
this
is
not
actually
installing
of
the
chain
code.
We
are
not
actually
installing
the
actual
chain
code
here.
Rather,
we
are
defining
the
definition
of
the
chain
code
to
our
pr
or
peers
that
you
will
near
future.
You
will
receive
a
chain
code
with
these
parameters
and
this
will
be
the
name
and
label
so
it
got
installed
now.
Let
me
install
this
into
the
second
pier,
which
is
up
to
year
one.
B
B
The
reason
why
I
chose
node.js
for
this
external
chain
code
or
for
this
meetup
is
because,
in
the
fabric
samples
we
have
the
example
only
for
the
for
the
golang
chain
code
and
in
the
internet
as
well.
I
try
to
find
out.
There
is
very
few
examples
that
are
available
for
the
node.js
external
chain
code
and
I
have
received
this
queries
quite
on
linkedin
and
in
through
other
mediums
as
well
that
they
they
don't
have
any
idea
of
setting
up
the
node
just
changing
for
external
input.
B
B
Folder
here-
and
this
is
the
chain
fabric
samples-
nothing
fancy
here-
this
is
the
sample
chain
code
that
I
just
copy
paste
it
from
the
fabric,
samples,
fab
cartoon
code,
same
structure
I
took
here-
I
I
made
a
few
modification
to
this.
So
first
is
this
docker
file,
because
when
you
are
running
the
chain
code
as
externally
input,
you
need
to
dockerize
it.
So
I
have
created
a
docker
file
out
of
it
and
the
second
thing
is
on
the
package.json
file.
B
So
here
in
the
start
script
I
have
made
it
to
start
it
as
a
as
a
chain
code
server,
not
as
the
normal,
using
the
legacy
method
where
we
were
not
running
the
chain
external
chain
code.
So
only
two
modification,
I've
done.
I
modified
this
start
script
and
the
docker
file.
So
I
had
this
docker
file
and
this
is
what
we
are
going
to
deploy
in
today's
demo
as
well.
This
fab
cartoon
code.
I
have
already
dockerized
this
and
I
have
already
published
this
chain
code
into
my
docker
repository.
B
Time
so
now
I
can
deploy
the
chain
code,
so
here
in
the
deploy
chain
code
part.
I
have
to
pass
my
chain
code
name.
So
this
is
the
external
chain
code
command
which
is
going
to
deploy
the
chain
code.
I'm
specifying
my
chain
code
image,
so
what
you
will
have
to
do
when
you
are
building
your
own
chain
code,
you
just
dockerize.
It
basically
build
the
image
and
push
it
to
docker
up,
and
you
can
you
can
reference
your
image
here.
B
If
you
have
image
like
if
it
is
on
the
private
repository
like
it
is
in
the
private
docker
repository
or
in
some
any
private
hub
repository,
you
can
basically
pass
the
image
full
sections
along
with
this
command.
So
we
have
a
flag
for
that
as
well,
where
you
can
pass
the
image
secret.
We
are
specifying
the
chain
code
name
here,
the
name
space
over
which
we
want
to
install
the
chain
code,
and
this
is
the
package
id
that
we
exported
as
an
environment.
B
So
I
will
take
up
the
questions
at
the
end,
so
you
can
you
can
post
the
questions,
but
I'm
going
to
take
the
questions
at
the
end.
Only
so
now,
if
I
see
if
I
to
get
parts
in
the
fabric
namespace,
we
should
have
one
my
c
this
one
as
well
my
cc
chain
code
that
is
running
as
a
container
or
a
port
okay.
So
now
we
have
installed
the
chain
code.
Now
it's
time
to
approve
the
chain
code
and
in
approval.
B
B
So
this
is
the
command
which
is
going
to
approve
the
chain
code.
We
are
passing
the
network
config
file,
the
identity
that
is
going
to
take
this
action,
the
target
peer
and
the
package
id,
and
here
you
have
to
pass
the
version
in
the
sequence
number
so
anytime
in
fabric
when
you
install
the
chain
code
or
even
when
you
approve
the
chain
code,
you
have
to
specify
this
version
of
the
sequence
id.
That
is
pretty
much
helpful
when
you
are
actually
upgrading
up
the
chain
code,
then,
where
you
are
specifying
those
policies.
B
B
B
So
let
me
put
the
command
to
commit
the
chain
code,
so
this
is
the
command,
and
I
told
you
that
only
one
organization
is
going
to
commit
the
chain
code.
So
here
we
are
passing
the
mspid,
the
user
and
the
version
and
the
sequence
number
and
the
chain
code
name,
and
this
is
the
policy
that
is
specified
in
the
approval
processes.
B
Then
I
am
passing
the
channel
name
and
with
this
command
we
should
be
able
to
basically
commit
the
chain
code,
so
it
got
committed
successfully
and
now
we
can
simply
invoke
and
query
the
chain
code.
So
let
me
just
first
invoke
the
query.
Let
me
just
do
a
invocation
first
and
then
we
can
do
the
query.
B
So
this
is
the
command
which
is
hlf.
Gene
code
input.
You
pass
the
connection
profile,
you
pass
the
admin
identity
here
or
the
user
entity.
You
pass
the
target
peer,
who
is
going
to
take
this
operation
and
you
specify
the
chain
code
name
and
the
channel
name.
And
after
that
here
we
are
passing
the
chain
code.
Details
like
the
function
which
you
want
to
invoke
from
the
chain
code
and
the
arguments
you
want
to
pass
so
using
hyphen
a
flag.
B
You
can
specify
the
arguments
so
the
fab
card,
encode
that
I
installed,
that
has
a
create
card
function
and
that
needs
five
parameters.
So
I
think
first
one
is
the
id.
Second
one
is
the,
I
think,
make
then
mortar,
then
color
and
the
owner.
So
I'm
passing
all
the
five
parameters
here,
and
this
should
invoke
the
chain
code
and
I
should
get
the
transaction
id
in
return.
B
Okay,
so
it
got
the
transaction
got
initiated,
we
got
the
transaction
id
and
if
you
try
to
query
the
chain
code
so
here,
the
difference
is
hlfj
input.
Query
this
time
instead
of
invoke,
it
is
query,
then
rest
of
the
parameter
is
same,
and
here
you
are
passing
the
function.
The
chain
code
function
and
the
argument-
and
one
thing
is
there
that
this
I
am
passing
the
empty
parameter
here,
because
this
plugin
expects
you
to
pass
at
least
one
parameter,
and
you
have
this.
B
B
So
this
should
show
me
the
record
that
we
just
inserted
with
these
details
like
the
yeah,
so
we
got
the
records,
we
got
the
key,
the
key
was
hundred
or
the
id
was
hundred,
and
then
we
got
the
color
the
make
the
model
and
the
owner.
We
got
all
those
things.
Let's
try
to
run
one
more
function.
I
think
that
was
query
card.
I'm
not
sure,
and
here
let
me
pass
the
car
id.
B
Yeah,
so
we
got
just
one
record,
so
in
the
previous,
when
we
were
getting
an
array
in
the
return,
but
this
time
it
is
our
object
and
yeah,
it
is
working
pretty
much
fine.
Now
now
I
think
I
have
covered
most
of
the
stuff
like
we
have
seen
the
ca
set
apart.
We
saw
our
peer
setup,
we
saw
the
order
set
up
and
then
we
did
the
channel
part
where
we
joined
the
channel.
B
I
installed
the
channel
join
the
channel
and
install
the
chain
code
as
well,
and
then
we
did
the
query
invocation
part
as
well,
so
I
think
yeah,
I'm
pretty
much
good
here
yeah.
So
just
one
thing
I
just
want
to
show
you
here
is
that
there
are
some
more
commands
as
well
that
I
just
want
to
show
you-
and
these
are
commands
that
you
might
not
be
needing
frequently,
but
it's
good
to
know
these
commands
as
well.
B
B
B
Let
me
clear
this
one
more
thing
I
just
want
to
show
is,
and
I
think
the
next
command
is
going
to
be
pretty
much
useful
for
you,
and
this
is
mostly
required
when
you
are
actually
doing
some
modification
onto
the
channel.
You
want
to
do
a
channel
update
process,
so
this
command
is
basically
going
to
inspect
on
your
channel
and
then
it
is
using
the
connection
profile
and
it
will
like
I'm
showing
the
response
in
this
my
channel.json
file
and
we'll
see
like
what
this
mychal.json
have
so
this.
B
B
B
Then
we
have
the
op
msp
as
well,
and
we
should
see
the
consenters
as
well,
which
are
basically
related
to
the
ordering
service.
So
if
I
try
to
search
constructor
so
here
you
can
see
the
concentra
and
we
have
only
one
consent,
because
you
are
having
only
one
ordering
node,
so
you
can
see
its
client
certificate
server
certificate
and
the
host
over
which
this
order
is
running.
Any
sport
as
well.
B
So
I
think
I
am
done
with
the
demo.
I
just
want
to
show
you
the
logs
as
well
or
let
me
do
one
thing:
let
me
show
you
the
couchdb
ui
as
well,
so
that
we
can
see
that
data
is
actually
processing
the
couchdb.
So
if
I
do
get
parts
in
the
fabric
name,
space
and
the
cowsdb
port
pod
or
the
container
is
within
the
within
the
pier
within
the
pa
pod,
so
we
have
to
use
it
to
to
get
the
data.
B
B
B
B
B
Okay.
The
next
question
is:
do
we
have
any
ui
instead
of
cli
okay?
So
there
is
one
open
source
project
that
is
that
we
are
actually
doing
on
and
and
though
we
don't
have
any
much
plans
for
that.
We
we
tried
it
as
a
as
a
kind
of
a
poc
and
yes
that
that
tool
is
basically
right.
Now
give
your
view
state
like
you,
can
see
the
all
the
components,
but
it
does
not
have
the
capability
of
actually
creating
up
the
network
from
the
ui.
A
B
So
I
will
once
I
find
that
I
will
just
post
it
in
the
chat,
the
ui
part
of
it
but
yeah,
but
that
is
that
is
not
our
primary
for
area
of
focus
that
project
we
did
that
and
and
and
this
I
think,
the
cli
that
we
are
giving
at
as
a
part
of
this
opera.
That
is,
I
think,
are
pretty
much
customizable
and
you
can
customize
it
as
per
your
need.
B
So
I
don't
think
so,
the
ui
that
that
we
are
building
or
that
we
are
planning
to
build
that
might
be
different
for
your
use
case
as
well.
So
if
you,
if
you
want
to
have
some
different
kind
of
user
interface,
maybe
you
want
to
have
you
want
to
provision
something
automatically
or
you
want
to
give
some
extra
options
to
you
use
it.
That
is
up
to
you
why
it
is.
B
A
B
Yeah,
so
deletion.
So
if
you
see,
if
I
show
you
my
terminal
window,
you
can
see
that
all
of
our
resources
they
are
using
pvcs
they're,
actually
bounded
to
the
pc.
So
even
if
I
delete
any
port-
or
let's
say
they
get
deleted
due
to
some
reason,
some
out
of
memory
or
any
anything
happens
and
it
happens,
it
is
automatically
going
to
attach
to
the
same
persistent
volume.
So
you
are
never
losing
the
data
like
accidentally.
B
Okay,
there
is
one
more
question:
how
connect
one
node
from
azure
one
from
aws?
Okay,
so
I
I
have
made
up
a
video
on
this
on
my
youtube
channel.
I
think
that
will
that
would
be
a
pretty
much
a
better
way
for
you
to
understand
this,
but
yeah.
This
is
pretty
much
possible.
You
can
have
two
different
units
cluster
and
you
can
you
you
can
basically
make
them
join
to
a
single
channel.
B
A
B
We
are
not
creating
a
test
data
anywhere
yeah,
so
so
on
chain
code,
if
you
see
like
I
just
I
just
created
one
transaction
and
that
I
did
I
like
when
I
had
to
do
the
transaction
only,
then
only
that
moment
I
basically
created
the
transaction
and
before
that
we
were
not
having
any
data.
So
if
you
see
my
couchdb
here
as
well,
I
have
only
one
record
and
this
record-
I
I
just
created
just
to
showcase
you,
the
invocation
part.
B
So
apart
from
that,
we
don't
have
any
test
data
anywhere
in
the
chain
code,
and
this
this
pretty
much
depends
on
how
you
have
structured
your
chain
code
as
well.
So
if
you
want
your
chain
code
to
have
some
test
data,
let's
say
you
as
soon
as
your
chain
code
starts.
You
want
to
write
some
data
to
the
ledger.
You
can
pretty
much
do
it,
but
again,
that
is
on
the
chain
code
part
not
on
this
operator.
B
So
there
is
one
client
example
integrations
as
well.
I
have
them
so
you
you
can
see.
This
is
the
operator
repository,
and
here
is
one
examples.
Photos
is
for
like
created
two
applications,
one
for
the
go
and
one
for
the
node.js,
so
you
can
use
either
you
can
use,
go
library
for
the
fabric
or
you
can
use
the
node.js
library
for
the
fabric
to
interact
with
your
kubernetes
cluster.
You
can
pretty
much
register
an
identity
and
role
and
led
invoke
the
code
so
pretty
much.
B
B
How
do
we
maintain
a
backup
for
pvc
and
application
factor?
Okay,
so
the
backup
thing
is
out
of
scope
of
this
hlf
operator.
This
operator
is
focusing
only
on
the
fabric,
part
and
backup
and
or
disaster
recovery
they
they
comes
under.
They
are
the
outside
of
the
scope
of
this
operator
because
they
apply
not
only
to
this
operator,
but
your
accumulated
cluster.
B
So
I
would
suggest
you
that
you
can
explore
tools
like
valero,
so
there
is
one
tool
valero
that
is
the
open
source
tool
and
widely
used,
and
I
also
have
one
video
around
it
on
my
youtube
channel.
So
probably
you
can
check
it
out
where
I
try
to
do
the
cluster
migration
from.
I
think
I
did
that
I
did
from
digital
ocean
to
asia,
so
I
make
migrate
the
entire
data
between
those
two
clusters
and
for
this
operator
as
well.