Setting up a Hyperledger Fabric Network with Multiple Chaincodes and Multiple Channels

Hyperledger Fabric is an enterprise grade framework for building permissioned blockchain networks. It’s a project supported and managed by the Linux Foundation. If you’re getting started with HL Fabric I’d strongly recommend you to read our previous articles to understand the architecture.

Terminologies

Before getting started with this, I’ll explain what exactly are channels and chaincodes.

Channels

Channels are the state store of an blockchain network which hold the application data generated during the lifecycle of the system. It’s used to store information like user data, purchase data, order data, invoices and more. In a Fabric network there can be multiple channels to provide privacy and security to the parties involved.

For instance if there are two parties who want have some data shared only between them, they can create a channel and store the corresponding information within that channel so that none of the other participants will be able to see that data.

Chaincodes

Chaincodes are the smart contracts that validate the each transaction that execute on the peer node. In a Fabric network chaincodes are the business logic to decide on what to be done on some data. Similar to channels, chaincodes can also be multiple in a network which helps to abstract the functional aspect of the network so that only allowed organizations will be able to invoke the chaincode.

For instance in a supply chain network, all the organizations will be able to record the sale data but only one organization will be managing and monitoring the entire network like an admin. Thus we can have one chaincode for the supplychain logic and one for admin operations like adding a new organization.

Since HL Fabric is a enterprise grade blockchain framework, it provides a lot of options for imparting security on to your network, one important feature being the multi ledger and multi channel network. This article will help you understand how to setup an Fabric network that involves multiple chaincodes and multiple channels.

Prerequisites

Before proceeding to the setting up part, please make sure the following processes are performed.

Installing Docker

Since entire Hyperledger Fabric is running on Docker, it’s necessary that you’ve it installed in your development machine.

Pulling the Images

Once you’ve installed the docker, pull the Hyperledger Fabric images from the repository with the following commands.

1
docker pull hyperledger/fabric-tools:x86_64-1.1.0
2
docker pull hyperledger/fabric-orderer:x86_64-1.1.0
3
docker pull hyperledger/fabric-peer:x86_64-1.1.0
4
docker pull hyperledger/fabric-javaenv:x86_64-1.1.0
5
docker pull hyperledger/fabric-ccenv:x86_64-1.1.0
6
docker pull hyperledger/fabric-ca:x86_64-1.1.0
7
docker pull hyperledger/fabric-couchdb:x86_64-0.4.6

And tag them as latest,

1
docker tag hyperledger/fabric-ca:x86_64-1.1.0 hyperledger/fabric-ca:latest
2
docker tag hyperledger/fabric-tools:x86_64-1.1.0 hyperledger/fabric-tools:latest
3
docker tag hyperledger/fabric-orderer:x86_64-1.1.0 hyperledger/fabric-orderer:latest
4
docker tag hyperledger/fabric-peer:x86_64-1.1.0 hyperledger/fabric-peer:latest
5
docker tag hyperledger/fabric-javaenv:x86_64-1.1.0 hyperledger/fabric-javaenv:latest
6
docker tag hyperledger/fabric-ccenv:x86_64-1.1.0 hyperledger/fabric-ccenv:latest
7
docker tag hyperledger/fabric-couchdb:x86_64-0.4.6 hyperledger/fabric-couchdb:latest

Finally verify by listing the docker images to check if everything is installed correctly.

1
docker images | grep hyperledger/fabric

Defining the Architecture

In our current example, we’ll be having the following components.

1 Orderer (orderer.example.com)
2 Organizations (org1, org2)
1 Peer per organization (peer0.org1.example.com, peer0.org2.example.com)
1 cli (fabric-tools)

This setup is mainly to make the process simpler. However, in production you’ll be having a much more complex setup for scalability. Also there will be cli container to create channels, join them and also install and instantiate chaincodes.

And we’ll be having two channels (channelone & channeltwo) and two chaincodes (firstchaincode & secondchaincode). Here the firstchaincode will be installed in channelone of Org1 & Org2 and the secondchaincode will be installed in channeltwo of Org2 alone. Thus secondchaincode and channeltwo will be a private one for Org2 alone.

Setting Up The Environment

As the first step, we need to create few basic things that is needed for running the Fabric network. Create a new folder in a suitable location.

1
mkdir multichain_network
2
cd multichain_network

Pulling Platform Tools The platform tools are necessary to create the certificates and configuration transaction blocks to setup the network. It’s specific to each platform thus you need to manually download it with the following script.

1
curl -sSL https://goo.gl/6wtTN5 | bash -s 1.1.0

This will create a bin folder in the current location, which contains the tools for the corresponding operations.

Next step is to create the following files and its content to start the network

docker-composer.yml - Which has our docker container’s configurations
crypto-config.yml - Which has the orderers and peers informations for generating the certificiates
configtx.yaml - That has the configuration information for building the genesis block and channel transaction files.

1
touch docker-composer.yml
2
touch crypto-config.yml
3
touch configtx.yaml

Docker Container Configuration

The containers are defined in the Docker compose file. This holds the configuration for the architecture. Copy paste the below content docker-compose.yml

1
version: '2'
2
networks:
3
  byfn:
4
services:
5

6
  orderer.example.com:
7
    container_name: orderer.example.com
8
    image: hyperledger/fabric-orderer
9
    environment:
10
      - ORDERER_GENERAL_LOGLEVEL=debug
11
      - ORDERER_GENERAL_LISTENADDRESS=0.0.0.0
12
      - ORDERER_GENERAL_GENESISMETHOD=file
13
      - ORDERER_GENERAL_GENESISFILE=/var/hyperledger/orderer/orderer.genesis.block
14
      - ORDERER_GENERAL_LOCALMSPID=OrdererMSP
15
      - ORDERER_GENERAL_LOCALMSPDIR=/var/hyperledger/orderer/msp
16
      - ORDERER_GENERAL_TLS_ENABLED=true
17
      - ORDERER_GENERAL_TLS_PRIVATEKEY=/var/hyperledger/orderer/tls/server.key
18
      - ORDERER_GENERAL_TLS_CERTIFICATE=/var/hyperledger/orderer/tls/server.crt
19
      - ORDERER_GENERAL_TLS_ROOTCAS=[/var/hyperledger/orderer/tls/ca.crt]
20
    working_dir: /opt/gopath/src/github.com/hyperledger/fabric
21
    command: orderer
22
    volumes:
23
    - ./channel-artifacts/genesis.block:/var/hyperledger/orderer/orderer.genesis.block
24
    - ./crypto-config/ordererOrganizations/example.com/orderers/orderer.example.com/msp:/var/hyperledger/orderer/msp
25
    - ./crypto-config/ordererOrganizations/example.com/orderers/orderer.example.com/tls/:/var/hyperledger/orderer/tls
26
    ports:
27
      - 7050:7050
28
    networks:
29
      - byfn
30

31
  peer0.org1.example.com:
32
    image: hyperledger/fabric-peer
33
    container_name: peer0.org1.example.com
34
    environment:
35
      - CORE_PEER_ID=peer0.org1.example.com
36
      - CORE_PEER_ADDRESS=peer0.org1.example.com:7051
37
      - CORE_PEER_GOSSIP_BOOTSTRAP=peer0.org1.example.com:7051
38
      - CORE_PEER_LOCALMSPID=Org1MSP
39
      - CORE_VM_ENDPOINT=unix:///host/var/run/docker.sock
40
      - CORE_VM_DOCKER_HOSTCONFIG_NETWORKMODE=multichain_network_byfn
41
      - CORE_LOGGING_LEVEL=DEBUG
42
      - CORE_PEER_TLS_ENABLED=true
43
      - CORE_PEER_GOSSIP_USELEADERELECTION=true
44
      - CORE_PEER_GOSSIP_ORGLEADER=false
45
      - CORE_PEER_PROFILE_ENABLED=true
46
      - CORE_PEER_TLS_CERT_FILE=/etc/hyperledger/fabric/tls/server.crt
47
      - CORE_PEER_TLS_KEY_FILE=/etc/hyperledger/fabric/tls/server.key
48
      - CORE_PEER_TLS_ROOTCERT_FILE=/etc/hyperledger/fabric/tls/ca.crt
49
      - CORE_LEDGER_STATE_STATEDATABASE=CouchDB
50
      - CORE_LEDGER_STATE_COUCHDBCONFIG_COUCHDBADDRESS=couchdb0:5984
51
      - CORE_LEDGER_STATE_COUCHDBCONFIG_USERNAME=
52
      - CORE_LEDGER_STATE_COUCHDBCONFIG_PASSWORD=
53
    depends_on:
54
      - couchdb0
55
    working_dir: /opt/gopath/src/github.com/hyperledger/fabric/peer
56
    command: peer node start
57
    volumes:
58
        - /var/run/:/host/var/run/
59
        - ./crypto-config/peerOrganizations/org1.example.com/peers/peer0.org1.example.com/msp:/etc/hyperledger/fabric/msp
60
        - ./crypto-config/peerOrganizations/org1.example.com/peers/peer0.org1.example.com/tls:/etc/hyperledger/fabric/tls
61
    ports:
62
      - 7051:7051
63
      - 7053:7053
64
    networks:
65
      - byfn
66

67

68
  peer0.org2.example.com:
69
    image: hyperledger/fabric-peer
70
    container_name: peer0.org2.example.com
71
    environment:
72
      - CORE_PEER_ID=peer0.org2.example.com
73
      - CORE_PEER_ADDRESS=peer0.org2.example.com:7051
74
      - CORE_PEER_GOSSIP_BOOTSTRAP=peer0.org2.example.com:7051
75
      - CORE_PEER_LOCALMSPID=Org2MSP
76
      - CORE_VM_ENDPOINT=unix:///host/var/run/docker.sock
77
      - CORE_VM_DOCKER_HOSTCONFIG_NETWORKMODE=multichain_network_byfn
78
      - CORE_LOGGING_LEVEL=DEBUG
79
      - CORE_PEER_TLS_ENABLED=true
80
      - CORE_PEER_GOSSIP_USELEADERELECTION=true
81
      - CORE_PEER_GOSSIP_ORGLEADER=false
82
      - CORE_PEER_PROFILE_ENABLED=true
83
      - CORE_PEER_TLS_CERT_FILE=/etc/hyperledger/fabric/tls/server.crt
84
      - CORE_PEER_TLS_KEY_FILE=/etc/hyperledger/fabric/tls/server.key
85
      - CORE_PEER_TLS_ROOTCERT_FILE=/etc/hyperledger/fabric/tls/ca.crt
86
      - CORE_LEDGER_STATE_STATEDATABASE=CouchDB
87
      - CORE_LEDGER_STATE_COUCHDBCONFIG_COUCHDBADDRESS=couchdb1:5984
88
      - CORE_LEDGER_STATE_COUCHDBCONFIG_USERNAME=
89
      - CORE_LEDGER_STATE_COUCHDBCONFIG_PASSWORD=
90
    depends_on:
91
      - couchdb1
92
    working_dir: /opt/gopath/src/github.com/hyperledger/fabric/peer
93
    command: peer node start
94
    volumes:
95
        - /var/run/:/host/var/run/
96
        - ./crypto-config/peerOrganizations/org2.example.com/peers/peer0.org2.example.com/msp:/etc/hyperledger/fabric/msp
97
        - ./crypto-config/peerOrganizations/org2.example.com/peers/peer0.org2.example.com/tls:/etc/hyperledger/fabric/tls
98
    ports:
99
      - 8051:7051
100
      - 8053:7053
101
    networks:
102
      - byfn
103

104
  couchdb0:
105
    container_name: couchdb0
106
    image: hyperledger/fabric-couchdb
107
    environment:
108
      - COUCHDB_USER=
109
      - COUCHDB_PASSWORD=
110
    ports:
111
      - "5984:5984"
112
    networks:
113
      - byfn
114

115
  couchdb1:
116
    container_name: couchdb1
117
    image: hyperledger/fabric-couchdb
118
    environment:
119
      - COUCHDB_USER=
120
      - COUCHDB_PASSWORD=
121
    ports:
122
      - "6984:5984"
123
    networks:
124
      - byfn
125

126
  cli:
127
    container_name: cli
128
    image: hyperledger/fabric-tools
129
    tty: true
130
    environment:
131
      - GOPATH=/opt/gopath
132
      - CORE_VM_ENDPOINT=unix:///host/var/run/docker.sock
133
      - CORE_LOGGING_LEVEL=DEBUG
134
      - CORE_PEER_ID=cli
135
      - CORE_PEER_ADDRESS=peer0.org1.example.com:7051
136
      - CORE_PEER_LOCALMSPID=Org1MSP
137
      - CORE_PEER_TLS_ENABLED=true
138
      - CORE_PEER_TLS_CERT_FILE=/opt/gopath/src/github.com/hyperledger/fabric/peer/crypto/peerOrganizations/org1.example.com/peers/peer0.org1.example.com/tls/server.crt
139
      - CORE_PEER_TLS_KEY_FILE=/opt/gopath/src/github.com/hyperledger/fabric/peer/crypto/peerOrganizations/org1.example.com/peers/peer0.org1.example.com/tls/server.key
140
      - CORE_PEER_TLS_ROOTCERT_FILE=/opt/gopath/src/github.com/hyperledger/fabric/peer/crypto/peerOrganizations/org1.example.com/peers/peer0.org1.example.com/tls/ca.crt
141
      - CORE_PEER_MSPCONFIGPATH=/opt/gopath/src/github.com/hyperledger/fabric/peer/crypto/peerOrganizations/org1.example.com/users/Admin@org1.example.com/msp
142
    working_dir: /opt/gopath/src/github.com/hyperledger/fabric/peer
143
    command: /bin/bash -c 'sleep 1000'
144
    volumes:
145
      - /var/run:/host/var/run/
146
      - ./crypto-config:/opt/gopath/src/github.com/hyperledger/fabric/peer/crypto/
147
      - ./chaincode:/opt/gopath/src/github.com/chaincode
148
      - ./channel-artifacts:/opt/gopath/src/github.com/hyperledger/fabric/peer/channel-artifacts
149
    networks:
150
      - byfn

Crypto Config

1
OrdererOrgs:
2
  - Name: Orderer
3
    Domain: example.com
4
    Specs:
5
      - Hostname: orderer
6
PeerOrgs:
7
  - Name: Org1
8
    Domain: org1.example.com
9
    EnableNodeOUs: true
10
    Template:
11
      Count: 1
12
    Users:
13
      Count: 1
14
  - Name: Org2
15
    Domain: org2.example.com
16
    EnableNodeOUs: true
17
    Template:
18
      Count: 1
19
    Users:
20
      Count: 1

Configtx.yaml

1
---
2
Profiles:
3
    OrdererGenesis:
4
        Capabilities:
5
            <<: *ChannelCapabilities
6
        Orderer:
7
            <<: *OrdererDefaults
8
            Organizations:
9
                - *OrdererOrg
10
            Capabilities:
11
                <<: *OrdererCapabilities
12
        Consortiums:
13
            SampleConsortium:
14
                Organizations:
15
                    - *Org1
16
                    - *Org2
17

18
    ChannelOne:
19
        Consortium: SampleConsortium
20
        Application:
21
            <<: *ApplicationDefaults
22
            Organizations:
23
                - *Org1
24
                - *Org2
25

26
            Capabilities:
27
                <<: *ApplicationCapabilities
28

29
    ChannelTwo:
30
        Consortium: SampleConsortium
31
        Application:
32
            <<: *ApplicationDefaults
33
            Organizations:
34
                - *Org2
35

36
            Capabilities:
37
                <<: *ApplicationCapabilities
38

39

40
Organizations:
41

42
    - &OrdererOrg
43
        Name: OrdererOrg
44
        ID: OrdererMSP
45
        MSPDir: crypto-config/ordererOrganizations/example.com/msp
46

47
    - &Org1
48
        Name: Org1MSP
49
        ID: Org1MSP
50
        MSPDir: crypto-config/peerOrganizations/org1.example.com/msp
51
        AnchorPeers:
52
            - Host: peer0.org1.example.com
53
              Port: 7051
54

55
    - &Org2
56
        Name: Org2MSP
57
        ID: Org2MSP
58
        MSPDir: crypto-config/peerOrganizations/org2.example.com/msp
59
        AnchorPeers:
60
            - Host: peer0.org2.example.com
61
              Port: 7051
62

63
Orderer: &OrdererDefaults
64
    OrdererType: solo
65
    Addresses:
66
        - orderer.example.com:7050
67
    BatchTimeout: 2s
68
    BatchSize:
69
        MaxMessageCount: 10
70
        AbsoluteMaxBytes: 99 MB
71
        PreferredMaxBytes: 512 KB
72

73
    Kafka:
74
        Brokers:
75
            - 127.0.0.1:9092
76
    Organizations:
77

78
Application: &ApplicationDefaults
79
    Organizations:
80

81
Capabilities:
82
    Global: &ChannelCapabilities
83
        V1_1: true
84

85
    Orderer: &OrdererCapabilities
86
        V1_1: true
87

88
    Application: &ApplicationCapabilities
89
        V1_1: true

As we mentioned above, we’ve create profiles for two channels ChannelOne and ChannelTwo. This will be used for generating channel transaction blocks in the following steps.

Set the Environment Variables

Before proceeding to the scripts, for easier usage I’ve used bunch of environment variables that will be used in the scripts. Export them in your terminal before proceeding to the scripts.

1
export CHANNEL_ONE_NAME=channelone
2
export CHANNEL_ONE_PROFILE=ChannelOne
3
export CHANNEL_TWO_NAME=channeltwo
4
export CHANNEL_TWO_PROFILE=ChannelTwo
5
export ORDERER_CA=/opt/gopath/src/github.com/hyperledger/fabric/peer/crypto/ordererOrganizations/example.com/orderers/orderer.example.com/msp/tlscacerts/tlsca.example.com-cert.pem

Generating the Certificates & Configuration Transaction Blocks

After defining the configuration, let’s get on to generating the certificates and the transactions blocks.

Generate Certificates

We’ll be using the cryptogen tool to generate the certificates for the defined organisations and users. It takes the crypto-config.yaml file as input and generates the certificates in crypto-config folder.

1
./bin/cryptogen generate --config=./crypto-config.yaml

Generate Genesis Block

After generating the certificates, we have to create the first block of our network which is called the genesis block. We’ll be using the configtxgen tool to generate it from configtx.yaml.

1
./bin/configtxgen -profile OrdererGenesis -outputBlock ./channel-artifacts/genesis.block

Generate Channel Transactions For each channel we will have to create a config transaction which is will be used when creating the channel.

1
# generate channel configuration transaction for channelone
2
./bin/configtxgen -profile ${CHANNEL_ONE_PROFILE} -outputCreateChannelTx ./channel-artifacts/${CHANNEL_ONE_NAME}.tx -channelID $CHANNEL_ONE_NAME
3

4
# generate channel configuration transaction for channeltwo
5
./bin/configtxgen -profile ${CHANNEL_TWO_PROFILE} -outputCreateChannelTx ./channel-artifacts/${CHANNEL_TWO_NAME}.tx -channelID $CHANNEL_TWO_NAME

Generate Anchor Peer Update Profile In order to update a peer to anchor peer, we have to create a transaction block signed by the corresponding OrgMSP.

1
# generate anchor peer for channelone transaction of org1
2
./bin/configtxgen -profile ${CHANNEL_ONE_PROFILE} -outputAnchorPeersUpdate ./channel-artifacts/Org1MSPanchors_${CHANNEL_ONE_NAME}.tx -channelID $CHANNEL_ONE_NAME -asOrg Org1MSP
3

4
# generate anchor peer for channelone channel transaction of org2
5
./bin/configtxgen -profile ${CHANNEL_ONE_PROFILE} -outputAnchorPeersUpdate ./channel-artifacts/Org2MSPanchors_${CHANNEL_ONE_NAME}.tx -channelID $CHANNEL_ONE_NAME -asOrg Org2MSP
6

7
# generate anchor peer for channeltwo transaction of org2
8
./bin/configtxgen -profile ${CHANNEL_TWO_PROFILE} -outputAnchorPeersUpdate ./channel-artifacts/Org2MSPanchors_${CHANNEL_TWO_NAME}.tx -channelID $CHANNEL_TWO_NAME -asOrg Org2MS

After completing these steps you can see that there will be two newly created folders in your project repo, the channel-artifacts & crypto-config. As you can see in the docker-compose file, these will be mounted in the peer and orderer volumes for the certificates to consume during the function of each of the nodes.

Starting The Network

Since we have all the certificates now, we can start all the components of the Fabric network. All we have to do is to start the docker services defined the docker-compose file.

1
docker-compose -f docker-compose.yml up -d

After this command is executed successfully, just check if everything is running with the following command.

1
docker ps

This will return all the running Docker containers and make sure you have 1 orderer, 2 peers, 2 couchdb and a cli running.

Channel Creation & Joining

We’ll be using the cli container to create and join the channels. While executing the commands from the cli container, the commands will be executed as a peer based on the environment variables set in the cli container. Since we have defined the Org1MSP as the default variable all the commands executed from the cli will be run as Org1 peers and when we need to change it to some other organization, we need to pass the corresponding environment variables during docker exec.

Creating Channel One as Org1 Peer

The channel creation is done by using the transaction tx that’s created in channel-artifacts folder.

1
docker exec cli peer channel create -o orderer.example.com:7050 -c $CHANNEL_ONE_NAME -f /opt/gopath/src/github.com/hyperledger/fabric/peer/channel-artifacts/${CHANNEL_ONE_NAME}.tx --tls --cafile $ORDERER_CA

Join the Channel One as Org1 Peer

After you create the channel, a new file named channelone.block will be created in the cli container which will be used to join the peer to the channel.

1
docker exec cli peer channel join -b ${CHANNEL_ONE_NAME}.block --tls --cafile $ORDERER_CA

Join the Channel One as Org2 Peer

Similarly we’ll change the environment variables to make the cli act as Org2 Peers and join the channel.

1
docker exec -e "CORE_PEER_LOCALMSPID=Org2MSP" -e "CORE_PEER_TLS_ROOTCERT_FILE=/opt/gopath/src/github.com/hyperledger/fabric/peer/crypto/peerOrganizations/org2.example.com/peers/peer0.org2.example.com/tls/ca.crt" -e "CORE_PEER_MSPCONFIGPATH=/opt/gopath/src/github.com/hyperledger/fabric/peer/crypto/peerOrganizations/org2.example.com/users/[email protected]/msp" -e "CORE_PEER_ADDRESS=peer0.org2.example.com:7051" cli peer channel join -b ${CHANNEL_ONE_NAME}.block --tls --cafile $ORDERER_CA

Update the Anchor Peers in Channel One

After joining the channel, we’ve to update the peers of each organization that will be acting as the anchor peer. In order to do that we’ll be using the anchorpeerupdate tx file that’s generated.

Org1 Peer

1
docker exec cli peer channel update -o orderer.example.com:7050 -c $CHANNEL_ONE_NAME -f /opt/gopath/src/github.com/hyperledger/fabric/peer/channel-artifacts/Org1MSPanchors_${CHANNEL_ONE_NAME}.tx --tls --cafile $ORDERER_CA

Org2 Peer

1
docker exec  -e "CORE_PEER_LOCALMSPID=Org2MSP" -e "CORE_PEER_TLS_ROOTCERT_FILE=/opt/gopath/src/github.com/hyperledger/fabric/peer/crypto/peerOrganizations/org2.example.com/peers/peer0.org2.example.com/tls/ca.crt" -e "CORE_PEER_MSPCONFIGPATH=/opt/gopath/src/github.com/hyperledger/fabric/peer/crypto/peerOrganizations/org2.example.com/users/[email protected]/msp" -e "CORE_PEER_ADDRESS=peer0.org2.example.com:7051" cli peer channel update -o orderer.example.com:7050 -c $CHANNEL_ONE_NAME -f /opt/gopath/src/github.com/hyperledger/fabric/peer/channel-artifacts/Org2MSPanchors_${CHANNEL_ONE_NAME}.tx --tls --cafile $ORDERER_CA

Creating Channel Two as Org2 Peer

1
docker exec -e "CORE_PEER_LOCALMSPID=Org2MSP" -e "CORE_PEER_TLS_ROOTCERT_FILE=/opt/gopath/src/github.com/hyperledger/fabric/peer/crypto/peerOrganizations/org2.example.com/peers/peer0.org2.example.com/tls/ca.crt" -e "CORE_PEER_MSPCONFIGPATH=/opt/gopath/src/github.com/hyperledger/fabric/peer/crypto/peerOrganizations/org2.example.com/users/[email protected]/msp" -e "CORE_PEER_ADDRESS=peer0.org2.example.com:7051" cli peer channel create -o orderer.example.com:7050 -c $CHANNEL_TWO_NAME -f /opt/gopath/src/github.com/hyperledger/fabric/peer/channel-artifacts/${CHANNEL_TWO_NAME}.tx --tls --cafile $ORDERER_CA

Joining Channel Two as Org2 Peer

1
docker exec -e "CORE_PEER_LOCALMSPID=Org2MSP" -e "CORE_PEER_TLS_ROOTCERT_FILE=/opt/gopath/src/github.com/hyperledger/fabric/peer/crypto/peerOrganizations/org2.example.com/peers/peer0.org2.example.com/tls/ca.crt" -e "CORE_PEER_MSPCONFIGPATH=/opt/gopath/src/github.com/hyperledger/fabric/peer/crypto/peerOrganizations/org2.example.com/users/[email protected]/msp" -e "CORE_PEER_ADDRESS=peer0.org2.example.com:7051" cli peer channel join -b ${CHANNEL_TWO_NAME}.block --tls --cafile $ORDERER_CA

Update the Anchor Peers in Channel Two

1
docker exec -e "CORE_PEER_LOCALMSPID=Org2MSP" -e "CORE_PEER_TLS_ROOTCERT_FILE=/opt/gopath/src/github.com/hyperledger/fabric/peer/crypto/peerOrganizations/org2.example.com/peers/peer0.org2.example.com/tls/ca.crt" -e "CORE_PEER_MSPCONFIGPATH=/opt/gopath/src/github.com/hyperledger/fabric/peer/crypto/peerOrganizations/org2.example.com/users/[email protected]/msp" -e "CORE_PEER_ADDRESS=peer0.org2.example.com:7051" cli peer channel update -o orderer.example.com:7050 -c $CHANNEL_TWO_NAME -f /opt/gopath/src/github.com/hyperledger/fabric/peer/channel-artifacts/Org2MSPanchors_${CHANNEL_TWO_NAME}.tx --tls --cafile $ORDERER_CA

Installing and Instantiating the Chaincodes

As per our architecture, we have created two channels and now we have to installed the corresponding chaincodes in the corresponding channels.

In our current example, we have two chaincodes each under ./chaincode/one & ./chaincode/two in the root folder. Also we have mounted the entire folder into the cli container under,

1
/opt/gopath/src/github.com/chaincode

Export Chaincode Name And Location Variables

We’ll store the chaincode name and the path in the environment variable to access it easily

1
export FIRST_CHAINCODE_NAME="firstchaincode"
2
export FIRST_CHAINCODE_SRC="github.com/chaincode/one"
3
export SECOND_CHAINCODE_NAME="secondchaincode"
4
export SECOND_CHAINCODE_SRC="github.com/chaincode/two"
5
export CHAINCODE_VERSION="1.0"

Install Chaincode (firstchaincode) in Org1 Peer

For installing the chaincode we’ll use peer chaincode install command, and we have to pass the name, location and the version of the chaincode to be installed. This process will install the runtime for the chaincode.

1
docker exec cli peer chaincode install -n $FIRST_CHAINCODE_NAME -p $FIRST_CHAINCODE_SRC -v $CHAINCODE_VERSION

Instantiate Chaincode (firstchaincode) in Org1 Peer

After installing the chaincode runtime, we have to instantiate to make it functional. This command needs TLS signing for the verification of the installer. The chaincode will be instantiated in the channelone of the network,

1
docker exec cli peer chaincode instantiate -o orderer.example.com:7050 --tls --cafile $ORDERER_CA -C $CHANNEL_ONE_NAME -c '{"Args":[]}' -n $FIRST_CHAINCODE_NAME -v $CHAINCODE_VERSION -P "OR('Org1MSP.member', 'Org2MSP.member')"

Install Chaincode (firstchaincode) in Org2 Peer

1
docker exec -e "CORE_PEER_LOCALMSPID=Org2MSP" -e "CORE_PEER_TLS_ROOTCERT_FILE=/opt/gopath/src/github.com/hyperledger/fabric/peer/crypto/peerOrganizations/org2.example.com/peers/peer0.org2.example.com/tls/ca.crt" -e "CORE_PEER_MSPCONFIGPATH=/opt/gopath/src/github.com/hyperledger/fabric/peer/crypto/peerOrganizations/org2.example.com/users/[email protected]/msp" -e "CORE_PEER_ADDRESS=peer0.org2.example.com:7051" cli peer chaincode install -n $FIRST_CHAINCODE_NAME -p $FIRST_CHAINCODE_SRC -v $CHAINCODE_VERSION

Instantiate Chaincode (firstchaincode) in Org2 Peer

1
docker exec -e "CORE_PEER_LOCALMSPID=Org2MSP" -e "CORE_PEER_TLS_ROOTCERT_FILE=/opt/gopath/src/github.com/hyperledger/fabric/peer/crypto/peerOrganizations/org2.example.com/peers/peer0.org2.example.com/tls/ca.crt" -e "CORE_PEER_MSPCONFIGPATH=/opt/gopath/src/github.com/hyperledger/fabric/peer/crypto/peerOrganizations/org2.example.com/users/[email protected]/msp" -e "CORE_PEER_ADDRESS=peer0.org2.example.com:7051" cli peer chaincode instantiate -o orderer.example.com:7050 --tls --cafile $ORDERER_CA -C $CHANNEL_ONE_NAME -c '{"Args":[]}' -n $FIRST_CHAINCODE_NAME -v $CHAINCODE_VERSION -P "OR('Org1MSP.member', 'Org2MSP.member')"

Install & Instantiate (secondchaincode) in Org2 Peer

The second chaincode is the private one (Like admin chaincode). This will be installed in only a specific organisation which will have rights to share the data. Thus in our scenario, we’ll install it only in Org2 peers and in channeltwo of the network.

1
docker exec  -e "CORE_PEER_LOCALMSPID=Org2MSP" -e "CORE_PEER_TLS_ROOTCERT_FILE=/opt/gopath/src/github.com/hyperledger/fabric/peer/crypto/peerOrganizations/org2.example.com/peers/peer0.org2.example.com/tls/ca.crt" -e "CORE_PEER_MSPCONFIGPATH=/opt/gopath/src/github.com/hyperledger/fabric/peer/crypto/peerOrganizations/org2.example.com/users/[email protected]/msp" -e "CORE_PEER_ADDRESS=peer0.org2.example.com:7051" cli peer chaincode install -n $SECOND_CHAINCODE_NAME -p $SECOND_CHAINCODE_SRC -v $CHAINCODE_VERSION
2

3
docker exec -e "CORE_PEER_LOCALMSPID=Org2MSP" -e "CORE_PEER_TLS_ROOTCERT_FILE=/opt/gopath/src/github.com/hyperledger/fabric/peer/crypto/peerOrganizations/org2.example.com/peers/peer0.org2.example.com/tls/ca.crt" -e "CORE_PEER_MSPCONFIGPATH=/opt/gopath/src/github.com/hyperledger/fabric/peer/crypto/peerOrganizations/org2.example.com/users/[email protected]/msp" -e "CORE_PEER_ADDRESS=peer0.org2.example.com:7051" cli peer chaincode instantiate -o orderer.example.com:7050 --tls --cafile $ORDERER_CA -C $CHANNEL_TWO_NAME -c '{"Args":[]}' -n $SECOND_CHAINCODE_NAME -v $CHAINCODE_VERSION -P "OR('Org1MSP.member', 'Org2MSP.member')"

With this part our entire network setup is over and we’re good to test the network. If we look at the couchdb admin, it’ll have the database for the corresponding channels and the chaincodes.

CouchDB of Org1

As we can see below it has one only one chaincode and one channel (channelone_firstchaincode)

CouchDB of Org2

And the org2 has one for each chaincode and channel (channelone_firstchaincode & channeltwo_secondchaincode) Thus org2 can read and write to both the channels with corresponding chaincode.

Hope this helps you to understand how to setup an Hyperledger Fabric Network with multiple channels and multiple chaincodes. This will be really helpful when you grow your network and start thinking about separating the chaincode logic to multiple parts.

Subscribe to our newsletter

Get the latest updates from our team delivered directly to your inbox.