►
From YouTube: Hyperledger Labs Webinar: Challenges with Hyperledger Fabric simulation and debugging of apps
Description
Hyperledger Project Webinar: Challenges with Hyperledger Fabric simulation and debugging of applications. This webinar showcased Umbra, an emulation tool for Hyperledger blockchains. It introduced Umbra, familiarize users with installing Umbra and getting their first Fabric network up and running and doing simple examinations of the network layout and packet flows and some simple debugging to confirm that the network is running.
----
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 #Blockchain
A
A
So
here's
is
a
little
bit
about
the
issues
that
at
least
I
have
been
facing
when
I'm
trying
to
experiment
with
blockchains
and
apps,
and
I'm
talking
here
since
the
the
beginning,
so
a
bit
about
blockchains.
That
we
know
is
that
we
are
trying
to
you,
know
blockchain
came
around
and
there
are
some
new
mechanisms
for
consensus.
A
A
A
A
So
somehow,
what
I
really
would
like
to
to
desire
here
is
some
sort
of
extensive
modification
of
these,
the
parameters
that
would
trigger
these
tests
and
to
check
them
extensively.
So
possibly,
I
would
like
to
make
this
this
tests
continuous
and
targeting
production
environment.
So
what
happens
nowadays?
B
A
Or
or
even
the
cloud
that
is
really
custom
for
for
their
use
case
and
they're
starting
testing
with
dockers,
like
containers
and
somehow
this
makes
difficult
to
to
share
tests,
share
results,
share
use
case
and
especially
compare
and
when
you
think
about
research.
On
top
of
these,
like
operational
research
and
extracting
metrics
from
that,
we
we
see
that
it's
it's
really
hard
to
to
make
this
this
test
reproducible.
A
We
know
that
it
changes
now
in
the
in
the
release
2.0,
so
that's
there's
some
special
functionalities
for
gene
code,
life
cycle,
private
data
and
channel
capabilities,
and
usually
what
happens
nowadays
when
you
read
the
fabric
documentation
is
that
you
see
that
we
have
initially,
we
had
some
video
first
network.
Now
we
have
a
test
network
and
these
are
really
well
defined,
docker
compose
files
that
we
can
run
and
create
the
crypto
material
and
on
in
a
set
of
scripts.
A
To
check
this
and
then
in
the
current
status
of
a
test
network,
because
the
topology
is
fixed,
we
need
to
understand
the
configuration
in
detail.
Somehow,
if
you
like
to
customize
it,
usually
the
the
chaincode
developer
is
like
is
confined
to
that
environment.
So
he,
if
she
needs
to
to
change
that,
it's
really
hard.
B
A
Reproducing
the
work
somehow
can
be
difficult,
especially
if
users
start
to
to
making
changes
into
this,
this
format
of
the
experiment
and
the
one
tool
that
existed
for
example,
that
was
now
the
deprecated
hyperledger
composer,
but
even
there
there
were
some
issues
with
how
the
test
would
be
reproducible
and
compare
and
compare
the
two
to
each
other.
So
what
came
to
mind
initially
long
ago
was
like
we.
A
I
saw
that
project
ombre
existed,
and
here
I'm
gonna
talk
a
little
bit
about
how
we
came
to
existence
and
what
are
we
doing
now?
So
for
those
who
don't
know
right,
the
hyper
ledger
is
under
the
hyperledger
labs
umbrella.
In
2018
there
was
a
internship
project
created
for
far
umbra
using
the
shadow
simulation
platform.
A
B
A
What
umbra
has
is
now.
It
has
six
components.
The
first
three
of
them
were
recorded
last
year.
The
the
following
three
of
them
were
coded.
I
coded
them
this
year.
So
what
umbra
provides
is
a
design
design
is
a
component
that
provides
apis
to
design
blockchain
experiments
in
a
modular
way.
So
this
would
be
like
the
creation
of
a
recipes
experiment
recipes,
and
the
scenario
is
the
component
that
consumes
this.
A
A
A
The
agent
is
a
standalone
component
that
can
be
instantiated
in
runtime.
The
apology
in
order
to
generate
some
anomalies
in
the
in
the
into
let's
say,
deployed
components
in
the
deployed
topology.
The
monitor
is
the
one
that
would
like
would
like
initially
to
see.
Hey
is
everything
actually
running
here
so
so
we,
I
created
this
monitoring
component
to
check
the
results
about
the
network,
the
containers,
the
nodes
and
the
environment
where
the
topologies
are
running
and
the
cli
is
a
newborn.
A
A
Each
one
of
the
components
is
a
micro
service,
so
there
are
grpc
interfaces
and
brought
the
buffer
message
defining
the
interaction
among
them.
The
topology
in
general,
in
the
design
component
is
a
graph,
so
there
are
notes
and
links
with
annotations
and
the
events
can
be
scheduled
in
different
manners.
A
The
topology
and
the
events
can
be
created
based
in
modular
plugins,
and
this
is
really
important,
because
each
blockchain
project
here
is
a
plugin
that
is
attached
and
extends
the
the
networking.
The
topology
features
so-
and
this
is
also
interesting
because
we
can
extend
umbra
in
diversity
of
settings,
and
one
really
interesting
point
here
to
make
is
that
umbra
provides
this
concept
of
environments
that
define
where
the
components
of
umbra
are
actually
executed.
A
This
is
a
simple,
really
simple
picture
about
that,
and
here
I'm
gonna
walk
through
the
each
one
of
the
the
red
numbers.
So
what
happens
first
is
that
when
you
download
umbra
and
install
it
in
your
machine,
you
have
what
you
need
to
run
an
experiment.
Basically,
you
import
use
the
umbra
design
here,
number
one.
A
We
import
number
design
apis
to
create
the
set
of
artifacts
that
define
the
topology
in
this
events
and
think
here
as
a
document,
and
this
document
could
be
shared
from
everyone
that
has
umbra
installed
on
them
and
with
this
document
only
if
the
person
has
the
ombre
installed,
he
could
run
the
same
experiments
everywhere
with
umbra.
So
what
happens
in
the
in
number
three
here
is
that
this
document
that
references,
the
topology,
the
events
and
the
artifacts
is
consumed
by
the
umbra
cli
component.
A
The
ombre
cli
component
uses
this
definition
of
topology
to
instantiate
the
environments.
This
would
be
number
four
in
the
in
the
picture,
so
number
14
here
that
each
one
of
the
environments
here
is
picture
as
these
gray
clouds.
In
the
background,
each
one
of
the
different
environments
would
have
its
components
instantiated
there,
for
example,
in
one
of
these
environments,
that
we
have
a
number
of
broker
running.
A
We
would
have
umbra
cli,
then,
knowing
that
all
the
components
are
successfully
deployed
in
these
environments.
It
regret
the
proper
interfaces
to
interact
with
these
components
and
it
contacts
here,
number
five
with
broker
and
say:
hey
now
that
you
are
instantiated,
please
run
the
experiments
for
me,
and
these
are
the
the
environments
that
you
need
to
contact,
and
these
are
the
components
running
there,
and
this
is
the
topology
and
the
the
events
that
you
need
to
run
there
for
me
and
the
umbra
broker
performs
all
of
that.
A
So
number
six
umbra
broker
contacts
each
one
of
the
umbra
scenario,
components
running
different
environments
and
tell
them
hey.
This
is
your
piece
of
topology
that
you
need
to
run
and
then
number
seven,
each
one
of
the
ombre
scenario:
components
running
in
a
different
environment
deploys
instantiates
the
the
the
proper
topology.
So
we
have
here
number
seven
that
each
one
of
the
nodes
of
the
blockchain
are
deployed.
A
A
A
I
got
these
amount
of
docker
containers
running
in
your
in
this
environment
that
you're
running.
Please
monitor
them
for
me
and
push
the
metrics
to
to
this
address,
and
then
the
monitoring
starts.
Pushing
this
monitoring
data
back
to
the
broker
and
number
nine
here
number
broker
then
performs
the
scheduling
of
the
events.
So
it
can.
It
can
contact
here,
for
example,
the
nodes
in
the
network
and
calling
the
software
development
kit
of
each
one
of
the
fabric
blocked
out
of
the
blockchains,
for
example,
fabric.
A
So
using
the
sdk
umbra
broker
reaches
the
the
nodes
and
realizes
all
the
available
functionalities
that
the,
for
example,
the
python
fabric
sdk,
provides
so
create
channels,
change,
codes,
instantiate
invoke
them
call
transactions
and
so
on
and
finally
number
10.
All
of
these
metrics
that
broker
is
monitoring,
push
it
to
a
database
and
program
it
to
be
visualized
in
a
platform.
A
A
B
B
A
I
put
the
install
command,
so
this
is
gonna,
make
omra
cli
to
contact
each
one
of
the
environments
and
hey
and
tell
them
hey,
install
all
of
the
clone
and
install
all
of
these
and
download
the
crypto
materials
and
a
lot
of
of
the
the
image.
The
current
image
is
too
useful
to
run
that,
then
we
we're
going
to
start
each
one
of
the
components
in
the
environments
and
then
we
begin
the
experiment,
the
beginning
triggers
the
execution
of
the
topology,
the
proper
instantiation
of
the
topology
and
then
the
triggering
of
the
events.
A
A
A
A
little
bit
about
the
details
about
umbra
and
guide
to
a
quick,
step-by-step
experiment
and
show
what
is
being
done
technically
in
details
in
the
in
umbra,
and
here
I'm
gonna
dig
deeply
a
little
bit
about
the
source
code,
but
not
too
much
details
and
so
umbra
is
developed
and
tested
in
ubuntu
20.04,
it's
written
in
python
3.8.
There
is
a
comprehensive
setup.buy
install
file
that
install
of
the
package
needed.
A
So
if
a
blockchain
project
is
extended
to
be
run
by
by
umbra,
then
there
is
the
need
to
create
this
unique
file
that
defines
how
the
dependencies
for
this
project
are
are
needed
to
to
be
installed.
For
example,
downloading
the
docker
images,
the
binaries
to
compile
the
crypto
material
and
even
the
sdk,
and
we
know
that
number
cli
performs
installation
of
the
local
and
remote
environments
and
nombra
uses
the
slash
stamp
umbra
for
the
source.
Configs
and
the
logs,
so
what
happens
when
you
execute
actually
remember?
A
So,
in
a
step
by
step,
what
we
need
first
is
to
design
the
the
experiment,
so
we
consume
them
for
apis,
and
here
is
the
creation
of
the
scenario
the
these
that
was
is
the
abstraction
of
what
contains
a
topology
and
the
set
of
events
there
and
the
topology
here
refers
to
what
would
be
called
the
fabric,
topology
and
nairobi,
topology
and
easy
topology
and
so
on.
So
it
realizes
the
abstraction
needed
for
each
one
of
the
blockchain
projects.
A
It
defines
the
instrumentation
to
create
the
artifacts
for
that.
It
means
that,
for
example,
for
fabric
it.
When
you
viewed
the
the
scenario
here,
the
the
configuration
of
the
design
api,
it
is
going
to
create
all
the
crypto
material,
it's
going
to
create
all
the
certificates,
the
keys,
download
the
images
and
perform
the
construction
of
this
reference
configuration
that
already
addresses
each
one
of
the
paths
of
this.
The
nodes
and
the
links
and
the
events
here
refer
to
the
sdk
interactions,
modifications
and
so
on.
A
B
A
A
I
have
a
default
environment
for
umbra,
that's
where
the
broker
can
run
or
other
components
can
run,
but
usually
is
the
broker
that
is
instantiated
there,
and
then
I
have
my
two
other
environments.
I
have
here
this
44
environment
that
is
going
to
execute
the
scenario
and
the
monitor
component
and-
and
I
have
here
the
definition
of
another.
A
That
is
also
going
to
have
a
different
scenario
and
a
monitor
component
here
just
define
how
the
the
topology
is
going
to
be
defined.
So
I
add
these
environments,
I
define
the
networks
for
these
environments.
I
create
a
link
for
among
these
these
networks.
I
say
that
this
network
is
going
to
run
this
specific
environment.
A
A
I
define
the
order
for
the
fabric
topology
the
cas,
and
then
I
defined
it
here,
a
quick
customization
for
the
config
tx
to
generate
the
configuration
of
the
the
each
one
of
these
nodes.
Then
I
add
my
links
to
the
network.
I
connect
my
each
one
of
my
orgs.
I
could
here
also
connect
different
peers
or
cas
or
orders
to
each
one
of
the
networks,
and
here
I
define
a
profile
for
them
called
links.
A
For
example,
here
for
the
python,
the
fabric
sdk,
we
schedule
everything,
and
then
we
save
this
environment
and,
as
I
said,
the
the
umbrella
pro
there
is
a
make
file
that
gives
you
the
the
freedom
to
install
each
one
of
the
components
and
everything
else.
So
what
I'm
going
to
do
now
is
run
this,
so
I
have
the
topology
experiment
defined.
A
A
So
I
load
my
configuration,
so
I
now
have
umbra
cli
loading,
all
the
scenarios
that
I
need
to
to
perform.
My
experiment,
if
I
needed
to
I'm
not
gonna,
do
this
now,
because
this
is
going
to
take
a
while.
But
if
I
needed
to,
I
would
call
install
here
and
the
number
cli
would
install
each
one
of
these
environments
for
me.
A
But
what
I'm
going
to
do
now
is
actually
start
the
the
components
and
here's
something
important,
because
I
need
the
proper
permissions
in
each
one
of
the
environments
to
to
run
them,
and
I
had
I
need
to
define
the
user
and
the
passwords
for
for
each
one
of
these
components
to
be
instantiated
there.
So
here
I
have
now
my
my
components.
Instantiated
in
my
virtual
machines.
I
have
two
virtual
machines:
one
is
called
environment,
44
and
the
other
is
environment.
A
So
if
we
check
the
logs
here
like
a
bit
fuzzy
but
here's
the
the
broker
logs
and
it's
calling
the
scenarios
and
all
the
instantiation
of
the
features
there
and
getting
back
the
experiment
and
scheduling
the
events
and
so
on,
and
then
we
see
that
our
experiment
started.
We
we
begin
it.
We
can
see
that
now
in
a
configuration
graphical
configuration
because
the
umbra
broker
already
created
the
database,
the
data
source
and
the
dashboard,
so
each
one
of
the
metrics
from
the
hosts.
A
A
A
Let's
say
here:
arg2
dot,
example.com
and
they
are
reachable
so
from
one
machine
to
another
because
they're,
as
I
said,
they're
tunnel-
and
here
I
could
say,
arc
four
as
well
and
r3.
That
is
running
the
same
machine,
so
they're,
reachable
by
better
names
and
so
on
so
they're
running.
So
here's
the
monitoring
component,
getting
the
metrics
from
the
the
node,
the
host
and
the
the
containers
here,
the
logs
above
the
umbra
scenario
as
well.
You
can
see
that
it
deployed
the
topology
and
so
on
and
then
getting
back
to
our
experiment.
A
What
we
need
now
to
finish
it.
We
need
to
end
the
experiment,
and
this
is
going
to
reach
now
the
broker
component
and
say:
hey:
stop
each
one
of
the
stop.
Node
stop
the
execution
of
each
one
of
the
tasks
that
you
send
to
the
components
so
broker
is
going
to
contact
scenario
and
say:
stop
the
topology
and
he's
going
to
contact
the
monitoring
and
say,
stop
the
monitoring
and
then.
B
A
B
A
A
We
have
the
components
running
and
here,
for
example,
umbra
monitor
and
ombre
scenario
are
running
in
a
virtual
machine
and
if
we
stop
these,
it's
going
to
trigger
the
stop
in
each
one
of
the
components
in
the
environments,
and
we
no
longer
have
them
running
there
in
in
any
of
the
virtual
machines
and
that's
it
if
we
would
like
to.
We
could
uninstall
the
umbra
in
each
one
of
the
environments
and
finally,
we
log
out
and
then
this
is
it
an
experiment
with
umbra
with
our
config
file
going
back
to
the
experiment.
A
What
we
had
is
that
the
parsing
the
deployment,
the
instantiation,
that
when
we
had
number
scenario,
deploying
the
actual
nodes
and
links
the
network
was
created
and
so
on.
I
can
go
back
here
to
to
further
questions
what
we
have
now
in
development
in
number.
What
I'm
doing
now
is
that
I'm
improving
the
the
event
scheduling
to
be
generic
enough
for
different
types
of
of
events.
A
A
A
There
was
an
internship
this
year
in
the
middle
of
the
year
about
adding
fuzzing
capabilities
to
hyperledger
number.
So
I'm
reviewing
this
source
code
and
merging
it,
and
also
I'm
planning
to
this
year
to
extend
umbra
for
iroha
and
indie
projects,
because
now
I'm
only
supporting
fabric
and
creating
different
examples
and
extend
the
documentation
there,
and
there
are
a
lot
of
future
work
going
on.
But
for
now
this
is
it
so
going
back
to
the
the
presentation.
A
B
A
Number
to
make
the
definition
of
the
hyper
parameters
of
the
blockchain
network
in
runtime
and
tune
it
in
a
closet
control
loop.
So
in
this
way
I
would
tune
the
blockchain
in
runtime
to
achieve
my
key
performance
indicators
for
a
particular
use
case,
and
that
was
the
initial
goal
when
I
talked
to
today
with
usbm
like
two
years
ago
about
why.
B
A
Would
like
to
run
this
code,
this
platform
and
a
perspective
about
automating
tests.
What
I'm
going
to
achieve
by
the
end
of
this
year
is
like
we
are
going
to
run
umbra
in
hundreds
and
thousands
of
nodes,
so
large
scale
experiments,
and
this
way
we
are
looking
forward
to
push
the
limits
of
the
consensus.
Algorithms
in
these
platforms
run
some
chaos,
monkey
engineering,
so
creating
a
lot
of
faults
and
see
how
the
the
network
is
going
to
behave,
and
here
I'm
going
to
talk
about
nodes
and
links
chains
of
resource
chains.
A
Of
of
I
don't
know
working
procedures.
So
in
this
way.
What
I
see
now
is
that
I'm
starting
to
to
get
closer
to
a
big
data
analysis
problem,
because
there's
a
lot
of
data
that
I'm
extracting
from
these
networks
in
runtime,
so
I'm
starting
to
use
some
machine
learning
algorithms
to
get
insights
about,
what's
actually
happening
in
the
network
and
correlate
the
resources
with
the
blockchain
functionalities
and
in
the
umbra
landscape.
A
So
in
this
way
I
would
like
to
have
umbra
as
a
reference
platform
to
somehow
validate
some
blockchains
and
dabs
and
to
support
in
this
way
mutual
blockchain
projects
and
then
finally,
is
like
each
one
of
the
use
case
that
would
be
built
using
umbra
would
have
this
footprint
defined
and
have
this
chaos.
Monkey
engineering
running
like
for
the
different
blockchains
and
testing
them
extensively
and
in
this
way.
Finally,
is
that
right?
We
could
run
this
with
the
way
that
I
showed
you
different
experiments
in
parallel
for
multiple
servers,
multiple
environments.
A
So
the
key
takeaways
from
this
talk
that
I'd
like
to
share
with
you
is
that
if
you
believe
it
or
or
not,
what
we
have
nowadays
is
like
blockchains
and
decentralized
applications.
Somehow
most
of
the
time
are
not
usually
are
really
tested
in
the
way
that
we
have
these
testing
requirements
defined
initially
in
the
talk,
umbra
defines
the
ways
of
testing
blockchains
in
a
simple
fast.
A
If
comparative
and
reproducible
way
that
nowadays,
I
I
think
is
really
hard
for
to
achieve
for
different
blockchain
projects,
so
it
tries
to
solve
this
testing
requirements
for
for
blockchains,
and
especially
it
tries
to
solve
that
with
automation,
because
we
need
to
automate
that
and
test
this
extensively
in
a
continuous
manner
for
for
different
use
cases,
and
then
here
the
way
that
umbra
can
can
achieve.
That
is
to
define
the
footprint
for
different
use
cases
and
in
the
future.
I
hope.
A
A
I
need
to
talk
also
for
about
this.
This
hyperledger
internships.
This
year
we
had
a
successful
internship
already
finished
by
buddy
that
he
helped
with
creating
this
fuzzing
capabilities
in
number.
That
is
turning
on
and
off
nodes
and
links
and
changing
the
the
resources
in
runtime
so
enabling
chaos
monkey
engineering.
Basically,
I'm
myself,
I'm
running
the
experiments
to
scale
umbra
in
multiple
servers
and
automate
that.
B
A
A
B
Thank
you
so
much
raphael.
This
is
wonderful,
such
great
information
and
such
an
interesting
demo
as
well.
We
do
have
several
questions,
so
I
want
to
make
sure
we
get
to
them,
I'm
just
going
to
share
them
in
the
order
they
came
in.
So
we
have
santiago
asking
if
you
are
collecting
the
metrics
in
grafana
via
prometheus.
A
I'm
collecting
them
via
influx
db.
It
was
easier
to
to
do
that
because
of
the
the
apis,
and
I
I
also
investigated
the
prometus,
but
it
would
take
me
a
while
to
create
the
plugin
for
that.
I
know
there
is
a
ca
advisor
and
so
on
and
prometus
and
grafana
really
were
integrated
for
that.
I
tested
them
before,
but
I
would
like
to
create
a
customized
solution
for
humber,
so
in
influx
the
v
fits
the
needs
for
that.
I
I
didn't
need
to
go
to
to
prometheus.
For
that.
B
A
A
For
my
experience,
I
have
at
least
in
a
set
say
a
server
with
12
cores,
16
gigs
of
memory.
I
would
run
100
nodes
in
connected
to
a
to
a
alberto
switch
or
even
more
so.
The
idea
is
that
we
were
going
to
actually
investigate
what
would
be
the
limits,
and
that
was
what
I'm
I
was
talking
about,
investigate
the
footprint
of
the
use
case,
and
that
involves
the
investigation
about
how
many
nodes
we
can
run
in
a
server
and
how
umbra
is
going
to
give
support
for
that.
B
A
B
A
B
A
A
We
have
the
better
capabilities
to
define
the
resource
allocations
for
the
nodes
and
links,
and
then
we
have
also
the
fuzzing
capabilities
that
we
could
turn
on
and
off
nodes
in
runtime
links
and
change
the
resources.
So
we
have
better,
let's
say
functionalities,
I
would
say
to
experiment
with
a
diversity
of
blockchain
projects,
not
just
fabric
fabric.
Now
I
gave
the
example,
but
we
are
going
to
extend
it
to
more
projects.
A
B
A
B
A
Called
umbra
monitor,
it
performs
the
the
monitoring
of
the
environment,
the
the
host
servers
and
the
docker
containers,
and
it
can
even
perform
the
monitoring
of
the
link.
How
many
packets
went
through
some
interface,
for
example,
and
it's
butte.
I
called
it
this
to
be
customized,
so
we
could
define
any
form
of
metrics
and
then
their
their
parameters,
their
let's
say
their
units
and
so
on,
and
this
is
pushed
to
influx
database
by
umbra
broker.
A
So
umbra
monitor
sends
all
the
monitoring
data
to
umbra
broker.
Ombre
broker,
collects
them
parses
this
data
and
pushes
it
to
the
influx
db,
and
all
of
that
goes
to
be
consumed
by
grafana
to
to
show,
as
I,
as
I
showed
here,
the
the
graphics
about
that,
and
this
is
in
a
stage
in
the
early
stage,
because
I
just
coded
this
like
last
week
and
now-
I'm
creating
new
visualization
methods
to
showcase
different
logs.
B
B
Real
quick
before
I
wrap
things
up,
could
you
just
share
if
someone
on
this
call
wants
to
get
started
with
umbra,
whether
in
using
it
or
actually
maybe
contributing
to
some
of
the
things
you
have
in
your
roadmap,
helping
figure
out
how
it
works
with
caliber?
How
can
they
get
started
on
that?
What's
the
best
way.
A
A
B
Okay,
great
so
join
the
mailing
list
and
check
out
the
github
page
as
well.
Thank
you
so
much
raphael.
I
am
just
going
to
do
a
couple
of
announcements
here
at
the
end,
lots
of
people
said
thank
you
for
the
presentation
in
the
chat.
So
I
think
this
is
a
really
a
really
great
discussion
and
lots
of
useful
information
for
people
to
re-watch
again
and
see
how
they
can
use
and
get
involved
in
the
umbra
project.
B
They
are
also
recorded
as
always,
so
you
can
watch
them
at
other
times
as
well.
If
you're
looking
for
more
content
on
just
what's
going
on
in
our
community
about
hyperledger
projects
or
use
cases,
you
can
visit
our
youtube
channel
and
also
our
website
as
well,
where
you
can
see
all
the
webinars
from
previous
sessions.
There's
just
a
lot
of
content
there
that
you
can
explore
and
please
get
involved.