Starting with Hyperledger fabric - Test network

By Anizhasree K on March 16, 2023

Hyperledger fabric Test network

Fabric provides a test network for learning and testing. Developers can use this network to test their applications. The network is only a tool for Learning and testing ,It is not a model for how to set up a network.

A Blockchain is a distributed system or ledger between computer network nodes and it serves as a digital database for information storage. The most well-known use of blockchain technology is for preserving a secure and transparent record of transactions in cryptocurrency systems like Bitcoin. Without the aid of a reliable third party, it ensures the security and authenticity of a data record and fosters confidence.  It aims to make it possible to share and record digital information without editing it. This is an innovative technology that serves as the basis for immutable ledgers, or records of transactions that cannot be changed, removed, or destroyed. That is why it is also referred as  distributed ledger technologies because of this (DLT). 

A plug-and-play blockchain platform called Hyperledger Fabric serves as a backbone for creating blockchain-based goods, services, and applications that are intended for usage by private businesses.  With several significant advantages over other well-known distributed ledger or blockchain technologies, Hyperledger Fabric is an open-source permissioned enterprise-grade DLT platform created for business contexts. 

Programming Languages

Instead of supporting domain-specific languages, Fabric enables general-purpose programming languages like Java, Go, and Node.js in smart contracts (DSL). 


Because of Fabric’s support for pluggable consensus methods, the platform may be more easily customized to meet specific use cases and trust models.  Thus, we can employ fully byzantine fault tolerant, crash tolerant, conventional byzantine fault tolerant, etc. Fully byzantine fault tolerant consensus may be viewed in some cases as superfluous and a significant performance throughput bottleneck. A crash fault tolerant (CFT) consensus protocol may be more appropriate in those circumstances, but a multi-party, decentralized use case may call for a more conventional byzantine fault tolerant (BFT) consensus system. 


At an excessive level, Fabric is constituted of the subsequent modular components:

  • After reaching consensus on the order of transactions, a pluggable ordering provider notifies peers of blocks.  
  • It is the responsibility of a pluggable club provider issuer to assign cryptographic identities to community members’ entities. 
  • The blocks output is distributed to various peers through a peer-to-peer gossip provider that is optionally available. This provider uses an ordering provider. 
  • For isolation, smart contracts (also known as “chaincode”) execute in a field environment like Docker. Even if they are written in well-known programming languages, they no longer have direct access to the ledger state. 
  • The ledger can be set up to direct several DBMSs. 
  • An endorsement and validation policy enforcement that is pluggable and may be individually set according to application. 

Benefits of Hyperledger Fabric

  • Permissioned network
  • Establish decentralized consider in a community of recognized individuals as opposed to an open community of nameless individuals.
  • Confidential transactions
  • Expose best the facts you need to proportion to the events you need to proportion it with.
  • Pluggable architecture
  • The blockchain industry needs a pluggable architecture rather than a domain specific one.
  • Easy to get started
  • Smart contracts can be done in the languages known, instead of learning custom languages and architectures.

Setting up the development environment

  • Git client
  • Go version 1.18.x/node.js
  • Docker version 18.03 or later
  • (macOS) Xcode Command Line Tools
  • SoftHSM
  • Jq

Before we begin:

Before starting the test network, clone the fabric-samples repository, and download the Fabric images. Since we follow the fabric samples provided by Fabric community through out the session.

Let us start using the Fabric test network

Fabric has provided a test network for learning by running nodes on your local machine. Developers can use the network to test their applications. The network is only a tool for Learning and testing and not as a model for how to set up a network. Modifications to the scripts are not appreciated and that may even break the network. It has limited configuration that should not be used as a template for deploying a production network:

  • Includes two peer organizations and an ordering organization.
  • Configured a single node Raft ordering service.
  • TLS Certificate Authority (CA) is not deployed, and All certificates are issued by the root CAs.
  • The sample network deploys a Fabric network with Docker Compose. Because the nodes are isolated within a Docker Compose network, the test network is not configured to connect to other running Fabric nodes.

The below command installs the Hyperledger Fabric platform-specific binaries and config files for the version into the /bin and /config directories of fabric-samples:

curl -sSL | bash -s — 2.2.2 1.4.9

Bring up the test network

Navigate to the test network directory by using the following command:

cd fabric-samples/test-network

From test-network directory, run the following command to remove any containers or artifacts from any previous runs:

./ down

You can then bring up the network by the following command. You will experience problems if you try to run the script from another directory, so make sure you are inside test-network directory:

./ up

This will create a Fabric network that consists of two peer nodes, one ordering node. If the command completes successfully, you will see the logs of the nodes being created:

The components of the test network

After the test network is deployed, Run the following command to list all Docker containers running on your machine. You should see the three nodes that were created by the script:

docker ps –a

Peers are the fundamental components of any Fabric network. Peers store the blockchain ledger and validate transactions before they are committed to the ledger. Peers run smart contracts that contain the business logic that is used to manage the assets on the blockchain ledger.

Every peer in the network belongs to an organization. In the test network, includes two peer organizations, Org1 and Org2. Each organization operates one peer each in the network, and

Every Fabric network will have an ordering service. Test network also includes a single orderer organization that maintains the network’s ordering service. Peers validate transactions and add blocks of transactions to the blockchain ledger, they do not decide on the order of transactions or include them into new blocks. On the distributed network, peers may be running far away from each other and not have a common view of when a transaction was created.

Creating a channel

We have peer and orderer nodes running on our machine, we can use the script to create a Fabric channel for transactions between organizations Org1 and Org2.A private layer of communication between specific network members is called channels. Channels can be used only by organizations invited to the channel and invisible to other members of the network. Each channel will have a separate blockchain ledger. Organizations that have been invited “join” their peers to the channel to store the channel ledger and validate the transactions on the channel.

Use the script to create a channel between Org1 and Org2 and join their peers to the channel. Run the bellow command to create a channel with the default name of mychannel:

./ createChannel

If the command was successful, the following message printed in your logs:

========= Channel successfully joined ===========

Use the channel flag to create a channel with a custom name. Example, the following command would create a channel with name channel1:

./ createChannel -c channel1

The channel flag also allows you to create different channels by specifying different channel names. After the creation of first channel, use the below command to create a second channel named channel2:

./ createChannel -c channel2

If you want to bring up the network and create a channel in a single step, use the command:

./ up createChannel

Starting a chaincode on the channel

Smart contracts contain the business logic that governs assets on the blockchain ledger. The network can invoke smart contracts to create assets on the ledger, change and transfer those assets and query smart contracts to read data on the ledger.

In Fabric, smart contracts are deployed on the network in packages called chaincode. A Chaincode is first installed on the peers of an organization and then deployed to a channel. This can then be used to endorse transactions and interact with the blockchain ledger. Before a chaincode can be deployed to a channel, its members must agree on a chaincode definition that establishes it. Once the required number of organizations agree, the chaincode definition can be committed to the channel, and the chaincode is ready to be used.

Once you have created a channel, you can start a chaincode on the channel using the following command:

./ deployCC -ccn basic -ccp ../asset-transfer-basic/chaincode-go -ccl go


./ deployCC -ccn basic -ccp ../asset-transfer-basic/chaincode- javascript -ccl javascript

The deployCC subcommand will install the asset-transfer (basic) chaincode on and and then deploy the chaincode on the channel specified using the channel flag (or mychannel if no channel is specified). If chaincode deployment is done for the first time; the script will install the chaincode dependencies. Use the language flag, -ccl, to install the Go, typescript or javascript versions of the chaincode. The asset-transfer (basic) chaincode in the asset-transfer-basic folder of the fabric-samples directory. This folder contains sample chaincode provided as examples and used by tutorials to highlight Fabric features.

Interacting with the network

After you bring up the test network, use the peer CLI to interact with your network. The peer CLI allows to invoke deployed smart contracts, update channels, or install and deploy new smart contracts from the CLI.

Make sure that operations are done from the test-network directory. The peer binaries will be there in the bin folder of the fabric-samples repository. Use the following command to add those binaries to your CLI Path:

export PATH=${PWD}/../bin:$PATH

Set the FABRIC_CFG_PATH to point to the core.yaml file in the fabric-samples repository:

export FABRIC_CFG_PATH=$PWD/../config/

You can now set the environment variables that allow you to operate the peer CLI as Org1:

# Environment variables for Org1
export CORE_PEER_TLS_ROOTCERT_FILE=${PWD}/organizations/peerOrganizations/
export CORE_PEER_MSPCONFIGPATH=${PWD}/organizations/peerOrganizations/
export CORE_PEER_ADDRESS=localhost:7051

If ./ deployCC -ccl go, is used to install, and start the asset-transfer (basic) chaincode, invoke the InitLedger function of the (Go) chaincode to put an initial list of assets on the ledger (if using typescript or javascript ./ deployCC -ccl javascript for example, invoke the InitLedger function of the respective chaincodes).

Run the following command to initialize the ledger with assets:

peer chaincode invoke -o localhost:7050 –ordererTLSHostnameOverride –tls –cafile”${PWD}/organizations/ordererOrganizations/” -C mychannel -n basic –peerAddresses localhost:7051 –tlsRootCertFiles”${PWD}/organizations/peerOrganizations/” –peerAddresses localhost:9051 tlsRootCertFiles”${PWD}/organizations/peerOrganizations/” -c ‘{“function”:”InitLedger”,”Args”:[]}’

If successful, you should see similar output to below:

-> INFO 001 Chaincode invoke successful. result: status:200

Query the ledger from your CLI. Run the following command to get the list of assets that is added to the channel ledger:

peer chaincode query -C mychannel -n basic -c ‘{“Args”:[“GetAllAssets”]}’

If successful, you should see the following output:

{"ID": "asset1", "color": "blue", "size": 5, "owner": "Tomoko", "appraisedValue": 300},
{"ID": "asset2", "color": "red", "size": 5, "owner": "Brad", "appraisedValue": 400},
{"ID": "asset3", "color": "green", "size": 10, "owner": "Jin Soo", "appraisedValue": 500},
{"ID": "asset4", "color": "yellow", "size": 10, "owner": "Max", "appraisedValue": 600},
{"ID": "asset5", "color": "black", "size": 15, "owner": "Adriana", "appraisedValue": 700},
{"ID": "asset6", "color": "white", "size": 15, "owner": "Michel", "appraisedValue": 800}

Chaincodes are invoked when a network member wants to transfer or change an asset on the ledger. Using the following command to change the owner of an asset on the ledger by invoking the asset-transfer (basic) chaincode:

peer chaincode invoke -o localhost:7050 –ordererTLSHostnameOverride –tls –cafile”${PWD}/organizations/ordererOrganizations/” -C mychannel -n basic –peerAddresses localhost:7051 –tlsRootCertFiles”${PWD}/organizations/peerOrganizations/” –peerAddresses localhost:9051 –tlsRootCertFile”${PWD}/organizations/peerOrganizations/” -c ‘{“function”:”TransferAsset”,”Args”:[“asset6″,”Christopher”]}’

If the command is successful, you will get the following response:

2019-12-04 17:38:21.048 EST [chaincodeCmd] chaincodeInvokeOrQuery -> INFO 001 Chaincode invoke successful. result: status:200

The endorsement policy for the asset-transfer (basic) chaincode requires the transaction to be signed by Org1 and Org2. The chaincode invokes command needs to target both and using the –peerAddresses flag. Since TLS is enabled for the network, the command also needs to reference the TLS certificate for each peer using the –tlsRootCertFiles flag.

After we invoke use another query to check how the invoke changed the assets on the blockchain ledger. Since we already queried the Org1 peer, query the chaincode running on the Org2 peer. Following is the environment variables to operate as Org2:

# Environment variables for Org2
export CORE_PEER_TLS_ROOTCERT_FILE=${PWD}/organizations/peerOrganizations/
export CORE_PEER_MSPCONFIGPATH=${PWD}/organizations/peerOrganizations/
export CORE_PEER_ADDRESS=localhost:9051

Query the asset-transfer (basic) chaincode running on

peer chaincode query -C mychannel -n basic -c ‘{“Args”:[“ReadAsset”,”asset6″]}’

The result will show that “asset6” was transferred to Christopher:


Bring down the network

You can bring down the network with the following command:

./ down

The above command will stop and remove the node and chaincode containers, delete the organization crypto material, remove the chaincode images from your Docker Registry. It will also remove the channel artifacts and docker volumes from previous runs.


The goal of Hyperledger is to provide an environment that makes it easier for businesses to use Blockchain technology. It also aims to provide simple APIs for development and interoperability. Although novel and difficult, the concepts are straightforward, modular, and simple enough for IT and business people to understand.  Hyperledger Blockchain can significantly improve your company network if you need to manage relationships, track transactions, have unbiased control, boost transparency, or if your system is prone to errors because of manual processes. 

Contact us!