HyperLeger Fabric SDK-go开发使用

最新推荐文章于 2023-04-14 17:34:12 发布
最新推荐文章于 2023-04-14 17:34:12 发布
阅读量1.2k 收藏 14
点赞数 2
分类专栏： Hyperledger Fabric 入门到放弃 文章标签： 区块链
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/demon_xi/article/details/118030714
版权 
git branch -a　　              // 查看分支，不出意外的话，此时分支应该处于 release-1.4
git checkout release-1.4              // 切换到 release-1.3 版本
git branch -v

git checkout release-1.4

报错过程：
进入fabric-samples 目录中的first-networkd子目录后，在使用“./byfn.sh —help”时报错：
error getting endorser client for channel: endorser client failed to connect to peer0.org1.example.com:7051: failed to create new connection: context deadline exceeded

报错过程：
进入fabric-samples 目录中的first-networkd子目录后，在使用“./byfn.sh —help”时报错：
error getting endorser client for channel: endorser client failed to connect to peer0.org1.example.com:7051: failed to create new connection: context deadline exceeded

解决方案：
 /etc/resolv.conf 注释掉 options timeout:2 attempts:3 rotate single-request-reopen，再次运行可成功。
cat /etc/resolv.conf 
sudo chmod 777 /etc/resolv.conf 
gedit /etc/resolv.conf

前言

本教程分为两部分，其中包括Fabric基础环境部署和Fabric-sdk-go的使用部分，涉及到的内容涵盖：

  • 编写crypto-config.yaml文件并生成秘钥文件
  • 编写configtx.yaml文件并生成创世快文件
  • 编写docker-compose.yaml文件，并运行成功
  • 编写链码
  • 为fabric-sdk-go编写配置文件，并调用成功
  • 使用fabric-sdk-go创建通道
  • 使用fabric-sdk-go把org1、org2（所有节点）加入通道
  • 使用fabric-sdk-go在指定节点安装自己编写的链码
  • 使用fabric-sdk-go实例化链码（配置背书策略）
  • 使用fabric-sdk-go调用链码
  • 使用fabric-sdk-go更新链码背书策略
  • 使用fabric-sdk-go调用新的链码（新的背书策略）

一、系统初始化

步骤1

生成秘钥文件

首先创建crypto-config.yaml文件：

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

查看目录生成crypto-config文件夹，证书文件存放在此文件夹，用这些文件进行系统初始化

步骤2

生成创世块文件

创建configtx.yaml文件，文件内容如下：

创建系统初始化文件夹:
mkdir channel-artifacts

生成创世快文件：
export FABRIC_CFG_PATH=$PWD
../bin/configtxgen -profile SampleMultiNodeEtcdRaft -channelID byfn-sys-channel -outputBlock ./channel-artifacts/genesis.block   byfn-sys-channel  ==代表通道名称

运行成功后可看到 channel-artifacts文件夹下生成了genesis.block文件。

步骤3

创建通道

../bin/configtxgen -profile TwoOrgsChannel -outputCreateChannelTx ./channel-artifacts/channel.tx -channelID mychannel
运行成功后可看到channel-artifacts文件夹下生成了channel.tx文件 
通道名 mychannel

为通道内的两个组织创建锚节点初始化文件

../bin/configtxgen -profile TwoOrgsChannel -outputAnchorPeersUpdate ./channel-artifacts/Org1MSPanchors.tx -channelID mychannel -asOrg Org1MSP
../bin/configtxgen -profile TwoOrgsChannel -outputAnchorPeersUpdate ./channel-artifacts/Org2MSPanchors.tx -channelID mychannel -asOrg Org2MSP

其中 锚节点 为：

    AnchorPeers:
        # AnchorPeers defines the location of peers which can be used
        # for cross org gossip communication.  Note, this value is only
        # encoded in the genesis block in the Application section context
        - Host: peer0.org1.example.com
          Port: 7051

   AnchorPeers:
        # AnchorPeers defines the location of peers which can be used
        # for cross org gossip communication.  Note, this value is only
        # encoded in the genesis block in the Application section context
        - Host: peer0.org2.example.com
          Port: 9051

运行成功后可看到channel-artifacts文件夹下生成了Org1MSPanchors.tx和Org2MSPanchors.tx两个文件。

二、启动节点

步骤一： 准备docker-compose文件

创建base.yaml文件：

创建docker-compose-local.yaml文件：

创建.env文件：

FABRIC_IMG_TAG=latest
SYS_CHANNEL=byfn-sys-channel
NETWORK=local_test

三、 启动容器

创建网络：

docker network create  local_test

docker-compose -f docker-compose-local.yaml up -d

如果运行成功，我们可以用docker ps命令查看运行起来的容器：

四、编写链码

创建chaincode文件夹：

cd ..
mkdir chaincode
cd chaincode

1 声明结构体（即链上存储的内容）

创建文件scoreStruct.go:

package main

// 根据实际需求，字段自行增删,以下只供参考
type Score struct {
	ObjectType	string	`json:"docType"`
	Name	string	`json:"Name"`		// 姓名
	Gender	string	`json:"Gender"`		// 性别
	StuID	string	`json:"StuID"`		// 学生学号
	Grade	string	`json:"Grade"`		// 年级
	Result	string	`json:"Result"`		// 成绩
	Time	string	`json:"Time"`		// 插入该数据的时间
Historys	[]HistoryItem	// 当前Score的历史记录
}

type HistoryItem struct {				// 交易hash，也是标志ID
	TxId	string
	Score	Score
}

2 编写链码

创建文件main.go:

package main

import (
	"github.com/hyperledger/fabric/core/chaincode/shim"
	"fmt"
	"github.com/hyperledger/fabric/protos/peer"
)

type ScoreChaincode struct {

}

func (t *ScoreChaincode) Init(stub shim.ChaincodeStubInterface) peer.Response{
	return shim.Success(nil)
}

func (t *ScoreChaincode) Invoke(stub shim.ChaincodeStubInterface) peer.Response{
	// 获取用户意图
	fun, args := stub.GetFunctionAndParameters()

	if fun == "addScore"{
		stub.SetEvent("addScore", []byte{})
		return t.addScore(stub, args)		// 添加成绩
	}else if fun == "queryScoreByNameAndGrade" {
		stub.SetEvent("queryScoreByNameAndGrade", []byte{})
		return t.queryScoreByNameAndGrade(stub, args)		// 根据姓名及年级查询成绩，假设不同年级存在同名
	}else if fun == "queryScoreDetailByStuID" {
		stub.SetEvent("queryScoreDetailByStuID", []byte{})
		return t.queryScoreDetailByStuID(stub, args)		// 根据学号查询成绩详细信息(包括历史信息)
	}else if fun == "updateScore" {
		stub.SetEvent("updateScore", []byte{})
		return t.updateScore(stub, args)		// 根据证书编号更新信息
	}else if fun == "delScore"{
		stub.SetEvent("delScore", []byte{})
		return t.delScore(stub, args)	// 根据证书编号删除信息
	}
	
	return shim.Error("指定的函数名称错误")

}

func main(){
	err := shim.Start(new(ScoreChaincode))
	if err != nil{
		fmt.Printf("启动ScoreChaincode时发生错误: %s", err)
	}
}

创建文件scoreCC.go:

package main

import (
	"github.com/hyperledger/fabric/core/chaincode/shim"
	"github.com/hyperledger/fabric/protos/peer"
	"encoding/json"
	"fmt"
	"bytes"
)

const DOC_TYPE = "ScoreObj"

// 保存sco
// args: Score
func PutScore(stub shim.ChaincodeStubInterface, sco Score) ([]byte, bool) {
    sco.ObjectType = DOC_TYPE

    b, err := json.Marshal(sco) //序列化
    if err != nil {
        return nil, false
    }
    // 保存sco状态
    err = stub.PutState(sco.StuID, b)
    if err != nil {
        return nil, false
    }

    return b, true
}

// 根据学号查询信息
// args: stuID
func GetScoreInfo(stub shim.ChaincodeStubInterface, stuID string) (Score, bool)  {
	var sco Score
	// 根据学号查询信息状态
	b, err := stub.GetState(stuID)
	if err != nil {
		return sco, false
	}

	if b == nil {
		return sco, false
	}
	
	// 对查询到的状态进行反序列化
	err = json.Unmarshal(b, &sco)
	if err != nil {
		return sco, false
	}
	
	// 返回结果
	return sco, true

}

// 根据指定的查询字符串实现富查询
func getEduByQueryString(stub shim.ChaincodeStubInterface, queryString string) ([]byte, error) {

	resultsIterator, err := stub.GetQueryResult(queryString)
	if err != nil {
		return nil, err
	}
	defer  resultsIterator.Close() //记得结束富查询调用
	
	// buffer is a JSON array containing QueryRecords
	var buffer bytes.Buffer
	
	bArrayMemberAlreadyWritten := false
	for resultsIterator.HasNext() {
		queryResponse, err := resultsIterator.Next()
		if err != nil {
			return nil, err
		}
		// Add a comma before array members, suppress it for the first array member
		if bArrayMemberAlreadyWritten == true {
			buffer.WriteString(",")
		}
	
		// Record is a JSON object, so we write as-is
		buffer.WriteString(string(queryResponse.Value))
		bArrayMemberAlreadyWritten = true
	}
	
	fmt.Printf("- getQueryResultForQueryString queryResult:\n%s\n", buffer.String())
	
	return buffer.Bytes(), nil

}

// 添加信息
// args: scoreObject
// 学生号为 key, Score 为 value
func (t *ScoreChaincode) addScore(stub shim.ChaincodeStubInterface, args []string) peer.Response {

	if len(args) != 1{
		return shim.Error("给定的参数个数不符合要求")
	}
	
	var sco Score
	err := json.Unmarshal([]byte(args[0]), &sco)
	if err != nil {
		return shim.Error("反序列化信息时发生错误")
	}
	
	// 查重: 身份证号码必须唯一
	_, exist := GetScoreInfo(stub, sco.StuID)
	if exist {
		return shim.Error("要添加的学生号已存在")
	}
	
	_, bl := PutScore(stub, sco)
	if !bl {
		return shim.Error("保存信息时发生错误")
	}
	
	return shim.Success([]byte("信息添加成功"))

}

// 根据姓名及年级查询信息
// args: Name, Grade
func (t *ScoreChaincode) queryScoreByNameAndGrade(stub shim.ChaincodeStubInterface, args []string) peer.Response {

	if len(args) != 2 {
		return shim.Error("给定的参数个数不符合要求")
	}
	name := args[0]
	grade := args[1]
	
	// 拼装CouchDB所需要的查询字符串(是标准的一个JSON串)
	// queryString := fmt.Sprintf("{\"selector\":{\"docType\":\"eduObj\", \"CertNo\":\"%s\"}}", CertNo)
	queryString := fmt.Sprintf("{\"selector\":{\"docType\":\"%s\", \"Name\":\"%s\", \"Grade\":\"%s\"}}", DOC_TYPE, name, grade)
	
	// 查询数据
	result, err := getEduByQueryString(stub, queryString)//getEduByQueryString
	if err != nil {
		return shim.Error("根据证书姓名及年级查询信息时发生错误")
	}
	if result == nil {
		return shim.Error("根据指定的姓名及年级没有查询到相关的信息")
	}
	return shim.Success(result)

}

// 根据学号查询详情（溯源）
// args: StuID
func (t *ScoreChaincode) queryScoreDetailByStuID(stub shim.ChaincodeStubInterface, args []string) peer.Response {
	if len(args) != 1 {
		return shim.Error("给定的参数个数不符合要求")
	}

	// 根据学号查询sco状态
	b, err := stub.GetState(args[0])
	if err != nil {
		return shim.Error("根据学号查询信息失败")
	}
	
	if b == nil {
		return shim.Error("根据学号没有查询到相关的信息")
	}
	
	// 对查询到的状态进行反序列化
	var sco Score
	err = json.Unmarshal(b, &sco)
	if err != nil {
		return  shim.Error("反序列化sco信息失败")
	}
	
	// 获取历史变更数据
	iterator, err := stub.GetHistoryForKey(sco.StuID)
	if err != nil {
		return shim.Error("根据指定的学号查询对应的历史变更数据失败")
	}
	defer iterator.Close()
	
	// 迭代处理
	var historys []HistoryItem
	var hisSco Score
	for iterator.HasNext() {
		hisData, err := iterator.Next()
		if err != nil {
			return shim.Error("获取sco的历史变更数据失败")
		}
	
		var historyItem HistoryItem
		historyItem.TxId = hisData.TxId
		json.Unmarshal(hisData.Value, &hisSco)
	
		if hisData.Value == nil {
			var empty Score
			historyItem.Score = empty
		}else {
			historyItem.Score = hisSco
		}
	
		historys = append(historys, historyItem)
	
	}
	
	sco.Historys = historys
	
	// 返回
	result, err := json.Marshal(sco)
	if err != nil {
		return shim.Error("序列化sco信息时发生错误")
	}
	return shim.Success(result)

}

// 根据学号更新信息
// args: Score Object
func (t *ScoreChaincode) updateScore(stub shim.ChaincodeStubInterface, args []string) peer.Response {
	if len(args) != 1{
		return shim.Error("给定的参数个数不符合要求")
	}

	var info Score
	err := json.Unmarshal([]byte(args[0]), &info)
	if err != nil {
		return  shim.Error("反序列化edu信息失败")
	}
	
	// 根据学号查询信息
	result, bl := GetScoreInfo(stub, info.StuID)
	if !bl{
		return shim.Error("根据学号查询信息时发生错误")
	}
	
	result.Name = info.Name
	result.Gender = info.Gender
	result.Grade = info.Grade
	result.Result = info.Result
	result.Time = info.Time
	
	_, bl = PutScore(stub, result)
	if !bl {
		return shim.Error("保存信息信息时发生错误")
	}
	
	return shim.Success([]byte("信息更新成功"))

}

// 根据学号删除信息（暂不对外提供）
// args: StuID
func (t *ScoreChaincode) delScore(stub shim.ChaincodeStubInterface, args []string) peer.Response {
	if len(args) != 1{
		return shim.Error("给定的参数个数不符合要求")
	}

	/*var edu Education
	result, bl := GetEduInfo(stub, info.EntityID)
	err := json.Unmarshal(result, &edu)
	if err != nil {
		return shim.Error("反序列化信息时发生错误")
	}*/
	
	err := stub.DelState(args[0])
	if err != nil {
		return shim.Error("删除信息时发生错误")
	}
	return shim.Success([]byte("信息删除成功"))

}

1.可能大家会疑惑区块链为什么还存在删除操作？

答：Fabric区块中存的是动作：“谁在什么时间对某个数据执行了什么操作”，例如：“张三在2020年8月10日插入了key为xxx，value为xx的数据”。而LevelDB或CouchDB存的是状态数据，及当前时间点某个key的状态(值)是什么。

  1. 为什么要用CouchDB?

**答：简单点讲就是只有用CouchDB才支持富查询等操作，LevelDB是不支持的。 **

3 创建CouchDB索引

mkdir META-INF/statedb/couchdb/indexes
cd META-INF/statedb/couchdb/indexes

创建indexNameGrade.json文件：

{"index":{"fields":["Name","Grade"]},"ddoc":"indexNameGrade", "name":"indexNameGrade","type":"json"}
因为链码中有通过Name和Grade两个字段来进行查询的函数。

五、SDK配置

创建配置目录：

cd .. # 回到主目录
mkdir sdkConfig
12

创建org1的配置文件org1_config.yaml:

特别注意其中的目录配置，在organizations下的cryptoPath里一定要是相对目录，从crypto-config的下一级目录开始，因为在文件的开始就已经配置了crypto-config目录的，不然在创建resmgmt Client的时候会提示user not found。

name: "org1-config"
#

# Copyright SecureKey Technologies Inc. All Rights Reserved.

#

# SPDX-License-Identifier: Apache-2.0

#
#

# The network connection profile provides client applications the information about the target

# blockchain network that are necessary for the applications to interact with it. These are all

# knowledge that must be acquired from out-of-band sources. This file provides such a source.

#

# copied from fabric-sdk-go/test/fixtures/config/config_e2e_pkcs11.yaml

#

# Schema version of the content. Used by the SDK to apply the corresponding parsing rules.

#
version: 1.0.0

#

# The client section used by GO SDK.

#
client:

  # Which organization does this application instance belong to? The value must be the name of an org

  # defined under "organizations"

  organization: Org1
  logging:
    # Develope can using debug to get more information
    #    level: debug
    level: info
  cryptoconfig:
    path: ${FABRIC_SDK_GO_PROJECT_PATH}/fixtures/crypto-config

  # Some SDKs support pluggable KV stores, the properties under "credentialStore"

  # are implementation specific

  credentialStore:
    # [Optional]. Used by user store. Not needed if all credentials are embedded in configuration
    # and enrollments are performed elswhere.
    path: "/tmp/examplestore"


  # [Optional] BCCSP config for the client. Used by GO SDK.

  BCCSP:
    security:
      enabled: true
      default:
        provider: "SW"
      hashAlgorithm: "SHA2"
      softVerify: true
      level: 256

  tlsCerts:
    # [Optional]. Use system certificate pool when connecting to peers, orderers (for negotiating TLS) Default: false
    systemCertPool: true
    # [Optional]. Client key and cert for TLS handshake with peers and orderers
    client:
      # 使用User1@org1的证书
      keyfile: ${FABRIC_SDK_GO_PROJECT_PATH}/fixtures/crypto-config/peerOrganizations/org1.example.com/users/User1@org1.example.com/tls/client.key
      certfile: ${FABRIC_SDK_GO_PROJECT_PATH}/fixtures/crypto-config/peerOrganizations/org1.example.com/users/User1@org1.example.com/tls/client.cert



################################## General part ##################################


#

# [Optional]. But most apps would have this section so that channel objects can be constructed

# based on the content below. If an app is creating channels, then it likely will not need this

# section.

#
channels:

  # name of the channel

  mychannel:
    # Required. list of orderers designated by the application to use for transactions on this
    # channel. This list can be a result of access control ("org1" can only access "ordererA"), or
    # operational decisions to share loads from applications among the orderers.  The values must
    # be "names" of orgs defined under "organizations/peers"
    # deprecated: not recommended, to override any orderer configuration items, entity matchers should be used.
    #    orderers:
    #      - orderer.example.com

    # 不要缺少当前channel的orderer节点
    orderers:
      - orderer0.example.com
      - orderer1.example.com
      - orderer2.example.com
    
    # Required. list of peers from participating orgs
    peers:
      peer0.org1.example.com:
        # [Optional]. will this peer be sent transaction proposals for endorsement? The peer must
        # have the chaincode installed. The app can also use this property to decide which peers
        # to send the chaincode install request. Default: true
        endorsingPeer: true
    
        # [Optional]. will this peer be sent query proposals? The peer must have the chaincode
        # installed. The app can also use this property to decide which peers to send the
        # chaincode install request. Default: true
        chaincodeQuery: true
    
        # [Optional]. will this peer be sent query proposals that do not require chaincodes, like
        # queryBlock(), queryTransaction(), etc. Default: true
        ledgerQuery: true
    
        # [Optional]. will this peer be the target of the SDK's listener registration? All peers can
        # produce events but the app typically only needs to connect to one to listen to events.
        # Default: true
        eventSource: true
    
      # Add other peers in mychannel for byfn
      peer1.org1.example.com:
        endorsingPeer: true
        chaincodeQuery: true
        ledgerQuery: true
        eventSource: true
    
      peer0.org2.example.com:
        endorsingPeer: true
        chaincodeQuery: true
        ledgerQuery: true
        eventSource: true
    
      peer1.org2.example.com:
        endorsingPeer: true
        chaincodeQuery: true
        ledgerQuery: true
        eventSource: true
    
    # [Optional]. The application can use these options to perform channel operations like retrieving channel
    # config etc.
    policies:
      #[Optional] options for retrieving channel configuration blocks
      queryChannelConfig:
        #[Optional] min number of success responses (from targets/peers)
        minResponses: 1
        #[Optional] channel config will be retrieved for these number of random targets
        maxTargets: 1
        #[Optional] retry options for query config block
        retryOpts:
          #[Optional] number of retry attempts
          attempts: 5
          #[Optional] the back off interval for the first retry attempt
          initialBackoff: 500ms
          #[Optional] the maximum back off interval for any retry attempt
          maxBackoff: 5s
          #[Optional] he factor by which the initial back off period is exponentially incremented
          backoffFactor: 2.0

#

# list of participating organizations in this network

#
organizations:
  Org1:
    mspid: Org1MSP
    # set msp files path
    cryptoPath: peerOrganizations/org1.example.com/users/{username}@org1.example.com/msp
    # Add peers for org1
    peers:
      - peer0.org1.example.com
      - peer1.org1.example.com

    # [Optional]. Certificate Authorities issue certificates for identification purposes in a Fabric based
    # network. Typically certificates provisioning is done in a separate process outside of the
    # runtime network. Fabric-CA is a special certificate authority that provides a REST APIs for
    # dynamic certificate management (enroll, revoke, re-enroll). The following section is only for
    # Fabric-CA servers.
    certificateAuthorities:
      - ca.org1.example.com
    
    #users:
    #  Admin:
    #    cert:
    #      pem: ${FABRIC_SDK_GO_PROJECT_PATH}/fixtures/crypto-config/peerOrganizations/org1.example.com/users/Admin@org1.example.com/msp/tlsca/tlsca.org1.example.com-cert.pem



  # the profile will contain public information about organizations other than the one it belongs to.

  # These are necessary information to make transaction lifecycles work, including MSP IDs and

  # peers with a public URL to send transaction proposals. The file will not contain private

  # information reserved for members of the organization, such as admin key and certificate,

  # fabric-ca registrar enroll ID and secret, etc.

  Org2:
    mspid: Org2MSP
    cryptoPath: peerOrganizations/org2.example.com/users/{username}@org2.example.com/msp

    # Add peers for org2
    peers:
      - peer0.org2.example.com
      - peer1.org2.example.com
    certificateAuthorities:
      - ca.org2.example.com


  # Orderer Org name

  ordererorg:
    # Membership Service Provider ID for this organization
    mspID: OrdererMSP
    cryptoPath: ordererOrganizations/example.com/users/{username}@example.com/msp
    orderers:
      - orderer0.example.com
      - orderer1.example.com
      - orderer2.example.com


#

# List of orderers to send transaction and channel create/update requests to. For the time

# being only one orderer is needed. If more than one is defined, which one get used by the

# SDK is implementation specific. Consult each SDK's documentation for its handling of orderers.

#
orderers:
  orderer0.example.com:
    # [Optional] Default: Infer from hostname
    url: grpcs://localhost:7050

    # these are standard properties defined by the gRPC library
    # they will be passed in as-is to gRPC client constructor
    grpcOptions:
      ssl-target-name-override: orderer0.example.com
      keep-alive-time: 0s
      keep-alive-timeout: 20s
      keep-alive-permit: false
      fail-fast: false
    
      #will be taken into consideration if address has no protocol defined, if true then grpc or else grpcs
      allow-insecure: false
    
    tlsCACerts:
      # Certificate location absolute path
      # Replace to orderer cert path
      path: ${FABRIC_SDK_GO_PROJECT_PATH}/fixtures/crypto-config/ordererOrganizations/example.com/orderers/orderer0.example.com/msp/tlscacerts/tlsca.example.com-cert.pem

  orderer1.example.com:
    url: grpcs://localhost:8050
    grpcOptions:
      ssl-target-name-override: orderer1.example.com
      keep-alive-time: 0s
      keep-alive-timeout: 20s
      keep-alive-permit: false
      fail-fast: false
      allow-insecure: false
    tlsCACerts:
      path: ${FABRIC_SDK_GO_PROJECT_PATH}/fixtures/crypto-config/ordererOrganizations/example.com/orderers/orderer1.example.com/msp/tlscacerts/tlsca.example.com-cert.pem

  orderer2.example.com:
    url: grpcs://localhost:9050
    grpcOptions:
      ssl-target-name-override: orderer2.example.com
      keep-alive-time: 0s
      keep-alive-timeout: 20s
      keep-alive-permit: false
      fail-fast: false
      allow-insecure: false
    tlsCACerts:
      path: ${FABRIC_SDK_GO_PROJECT_PATH}/fixtures/crypto-config/ordererOrganizations/example.com/orderers/orderer2.example.com/msp/tlscacerts/tlsca.example.com-cert.pem

#

# List of peers to send various requests to, including endorsement, query

# and event listener registration.

#
peers:
  peer0.org1.example.com:

    # this URL is used to send endorsement and query requests

    # [Optional] Default: Infer from hostname

    # 表明使用grpcs协议，设置IP和端口号，使用域名会无法连接

    # url: grpcs://peer0.org1.example.com:7051

​    url: grpcs://localhost:7051

    grpcOptions:
      ssl-target-name-override: peer0.org1.example.com
      keep-alive-time: 0s
      keep-alive-timeout: 20s
      keep-alive-permit: false
      fail-fast: false
    
      #will be taken into consideration if address has no protocol defined, if true then grpc or else grpcs
      allow-insecure: false
    
    tlsCACerts:
      # Certificate location absolute path
      path: ${FABRIC_SDK_GO_PROJECT_PATH}/fixtures/crypto-config/peerOrganizations/org1.example.com/tlsca/tlsca.org1.example.com-cert.pem

  peer1.org1.example.com:
    # this URL is used to send endorsement and query requests
    # [Optional] Default: Infer from hostname
    # 表明使用grpcs协议，设置IP和端口号，使用域名会无法连接
    # url: grpcs://peer0.org1.example.com:7051
    url: grpcs://localhost:8051
    grpcOptions:
      ssl-target-name-override: peer1.org1.example.com
      keep-alive-time: 0s
      keep-alive-timeout: 20s
      keep-alive-permit: false
      fail-fast: false

      #will be taken into consideration if address has no protocol defined, if true then grpc or else grpcs
      allow-insecure: false
    
    tlsCACerts:
      # Certificate location absolute path
      path: ${FABRIC_SDK_GO_PROJECT_PATH}/fixtures/crypto-config/peerOrganizations/org1.example.com/tlsca/tlsca.org1.example.com-cert.pem

  peer0.org2.example.com:
    # Replace the port
    url: grpcs://localhost:9051
    grpcOptions:
      ssl-target-name-override: peer0.org2.example.com
      keep-alive-time: 0s
      keep-alive-timeout: 20s
      keep-alive-permit: false
      fail-fast: false

      #will be taken into consideration if address has no protocol defined, if true then grpc or else grpcs
      allow-insecure: false
    tlsCACerts:
      path: ${FABRIC_SDK_GO_PROJECT_PATH}/fixtures/crypto-config/peerOrganizations/org2.example.com/tlsca/tlsca.org2.example.com-cert.pem

  peer1.org2.example.com:
    # Replace the port
    url: grpcs://localhost:10051
    grpcOptions:
      ssl-target-name-override: peer1.org2.example.com
      keep-alive-time: 0s
      keep-alive-timeout: 20s
      keep-alive-permit: false
      fail-fast: false

      #will be taken into consideration if address has no protocol defined, if true then grpc or else grpcs
      allow-insecure: false
    tlsCACerts:
      path: ${FABRIC_SDK_GO_PROJECT_PATH}/fixtures/crypto-config/peerOrganizations/org2.example.com/tlsca/tlsca.org2.example.com-cert.pem

# Fabric-CA is a special kind of Certificate Authority provided by Hyperledger Fabric which allows

# certificate management to be done via REST APIs. Application may choose to use a standard

# Certificate Authority instead of Fabric-CA, in which case this section would not be specified.

#
certificateAuthorities:
  ca.org1.example.com:
    url: http://localhost:7054
    tlsCACerts:
      # Certificate location absolute path
      path: ${FABRIC_SDK_GO_PROJECT_PATH}/fixtures/crypto-config/peerOrganizations/org1.example.com/ca/ca.org1.example.com-cert.pem
      # Client key and cert for SSL handshake with Fabric CA
      #client:
      #  key:
      #    path: /home/alextan/blockchain/fabric/fabric-samples-1.4/raft-local-test/crypto-config/peerOrganizations/tls.example.com/users/User1@tls.example.com/tls/client.key
      #  cert:
      #    path: /home/alextan/blockchain/fabric/fabric-samples-1.4/raft-local-test/crypto-config/peerOrganizations/tls.example.com/users/User1@tls.example.com/tls/client.crt
    # Fabric-CA supports dynamic user enrollment via REST APIs. A "root" user, a.k.a registrar, is
    # needed to enroll and invoke new users.
    registrar:
      enrollId: admin
      enrollSecret: adminpw
    # [Optional] The optional name of the CA.
    caName: ca.org1.example.com

  ca.org2.example.com:
    url: http://localhost:8054
    tlsCACerts:
      # Certificate location absolute path
      path: ${FABRIC_SDK_GO_PROJECT_PATH}/fixtures/crypto-config/peerOrganizations/org2.example.com/ca/ca.org2.example.com-cert.pem
      # Client key and cert for SSL handshake with Fabric CA
      #client:
      #  key:
      #    path: /home/alextan/blockchain/fabric/fabric-samples-1.4/raft-local-test/crypto-config/peerOrganizations/tls.example.com/users/User1@tls.example.com/tls/client.key
      #  cert:
      #    path: /home/alextan/blockchain/fabric/fabric-samples-1.4/raft-local-test/crypto-config/peerOrganizations/tls.example.com/users/User1@tls.example.com/tls/client.crt
    # Fabric-CA supports dynamic user enrollment via REST APIs. A "root" user, a.k.a registrar, is
    # needed to enroll and invoke new users.
    registrar:
      enrollId: admin
      enrollSecret: adminpw
    # [Optional] The optional name of the CA.
    caName: ca.org2.example.com

entitymatchers:
  peer:
    - pattern: (\w*)peer0.org1.example.com(\w*)
      urlsubstitutionexp: grpcs://localhost:7051
      ssltargetoverrideurlsubstitutionexp: peer0.org1.example.com
      mappedhost: peer0.org1.example.com

    - pattern: (\w*)peer1.org1.example.com(\w*)
      urlsubstitutionexp: grpcs://localhost:8051
      ssltargetoverrideurlsubstitutionexp: peer1.org1.example.com
      mappedhost: peer1.org1.example.com
    
    - pattern: (\w*)peer0.org2.example.com(\w*)
      urlsubstitutionexp: grpcs://localhost:9051
      ssltargetoverrideurlsubstitutionexp: peer0.org2.example.com
      mappedhost: peer0.org2.example.com
    
    - pattern: (\w*)peer1.org2.example.com(\w*)
      urlsubstitutionexp: grpcs://localhost:10051
      ssltargetoverrideurlsubstitutionexp: peer1.org2.example.com
      mappedhost: peer1.org2.example.com

  orderer:
    - pattern: (\w*)orderer0.example.com(\w*)
      urlsubstitutionexp: localhost:7050
      ssltargetoverrideurlsubstitutionexp: orderer0.example.com
      mappedhost: orderer0.example.com
    - pattern: (\w*)orderer1.example.com(\w*)
      urlsubstitutionexp: localhost:8050
      ssltargetoverrideurlsubstitutionexp: orderer1.example.com
      mappedhost: orderer1.example.com
    - pattern: (\w*)orderer2.example.com(\w*)
      urlsubstitutionexp: localhost:9050
      ssltargetoverrideurlsubstitutionexp: orderer2.example.com
      mappedhost: orderer2.example.com

  certificateAuthorities:
    - pattern: (\w*)ca.org1.example.com(\w*)
      urlSubstitutionExp: http://localhost:7054
      mappedHost: ca.org1.example.com
    

    - pattern: (\w*)ca.org2.example.com(\w*)
      urlSubstitutionExp: http://localhost:8054
      mappedHost: ca.org2.example.com

创建org2_config.yaml的文件：

name: "org1-config"
#
# Copyright SecureKey Technologies Inc. All Rights Reserved.
#
# SPDX-License-Identifier: Apache-2.0
#
#
# The network connection profile provides client applications the information about the target
# blockchain network that are necessary for the applications to interact with it. These are all
# knowledge that must be acquired from out-of-band sources. This file provides such a source.
#

# copied from fabric-sdk-go/test/fixtures/config/config_e2e_pkcs11.yaml

#
# Schema version of the content. Used by the SDK to apply the corresponding parsing rules.
#
version: 1.0.0

#
# The client section used by GO SDK.
#
client:
  # Which organization does this application instance belong to? The value must be the name of an org
  # defined under "organizations"
  organization: Org2
  logging:
    # Develope can using debug to get more information
    #    level: debug
    level: info
  cryptoconfig:
    path: ${FABRIC_SDK_GO_PROJECT_PATH}/fixtures/crypto-config
  # Some SDKs support pluggable KV stores, the properties under "credentialStore"
  # are implementation specific
  credentialStore:
    # [Optional]. Used by user store. Not needed if all credentials are embedded in configuration
    # and enrollments are performed elswhere.
    path: "/tmp/examplestore"


  # [Optional] BCCSP config for the client. Used by GO SDK.
  BCCSP:
    security:
      enabled: true
      default:
        provider: "SW"
      hashAlgorithm: "SHA2"
      softVerify: true
      level: 256

  tlsCerts:
    # [Optional]. Use system certificate pool when connecting to peers, orderers (for negotiating TLS) Default: false
    systemCertPool: true
    # [Optional]. Client key and cert for TLS handshake with peers and orderers
    client:
      # 使用User1@org2的证书
      keyfile: ${FABRIC_SDK_GO_PROJECT_PATH}/fixtures/crypto-config/peerOrganizations/org2.example.com/users/User1@org2.example.com/tls/client.key
      certfile: ${FABRIC_SDK_GO_PROJECT_PATH}/fixtures/crypto-config/peerOrganizations/org2.example.com/users/User1@org2.example.com/tls/client.cert



################################## General part ##################################


#
# [Optional]. But most apps would have this section so that channel objects can be constructed
# based on the content below. If an app is creating channels, then it likely will not need this
# section.
#
channels:
  # name of the channel
  mychannel:
    # Required. list of orderers designated by the application to use for transactions on this
    # channel. This list can be a result of access control ("org1" can only access "ordererA"), or
    # operational decisions to share loads from applications among the orderers.  The values must
    # be "names" of orgs defined under "organizations/peers"
    # deprecated: not recommended, to override any orderer configuration items, entity matchers should be used.
    #    orderers:
    #      - orderer.example.com

    # 不要缺少当前channel的orderer节点
    orderers:
      - orderer0.example.com
      - orderer1.example.com
      - orderer2.example.com

    # Required. list of peers from participating orgs
    peers:
      peer0.org1.example.com:
        # [Optional]. will this peer be sent transaction proposals for endorsement? The peer must
        # have the chaincode installed. The app can also use this property to decide which peers
        # to send the chaincode install request. Default: true
        endorsingPeer: true

        # [Optional]. will this peer be sent query proposals? The peer must have the chaincode
        # installed. The app can also use this property to decide which peers to send the
        # chaincode install request. Default: true
        chaincodeQuery: true

        # [Optional]. will this peer be sent query proposals that do not require chaincodes, like
        # queryBlock(), queryTransaction(), etc. Default: true
        ledgerQuery: true

        # [Optional]. will this peer be the target of the SDK's listener registration? All peers can
        # produce events but the app typically only needs to connect to one to listen to events.
        # Default: true
        eventSource: true

      # Add other peers in mychannel for byfn
      peer1.org1.example.com:
        endorsingPeer: true
        chaincodeQuery: true
        ledgerQuery: true
        eventSource: true

      peer0.org2.example.com:
        endorsingPeer: true
        chaincodeQuery: true
        ledgerQuery: true
        eventSource: true

      peer1.org2.example.com:
        endorsingPeer: true
        chaincodeQuery: true
        ledgerQuery: true
        eventSource: true

    # [Optional]. The application can use these options to perform channel operations like retrieving channel
    # config etc.
    policies:
      #[Optional] options for retrieving channel configuration blocks
      queryChannelConfig:
        #[Optional] min number of success responses (from targets/peers)
        minResponses: 1
        #[Optional] channel config will be retrieved for these number of random targets
        maxTargets: 1
        #[Optional] retry options for query config block
        retryOpts:
          #[Optional] number of retry attempts
          attempts: 5
          #[Optional] the back off interval for the first retry attempt
          initialBackoff: 500ms
          #[Optional] the maximum back off interval for any retry attempt
          maxBackoff: 5s
          #[Optional] he factor by which the initial back off period is exponentially incremented
          backoffFactor: 2.0

#
# list of participating organizations in this network
#
organizations:
  Org1:
    mspid: Org1MSP
    # set msp files path
    cryptoPath: peerOrganizations/org1.example.com/users/{username}@org1.example.com/msp
    # Add peers for org1
    peers:
      - peer0.org1.example.com
      - peer1.org1.example.com

    # [Optional]. Certificate Authorities issue certificates for identification purposes in a Fabric based
    # network. Typically certificates provisioning is done in a separate process outside of the
    # runtime network. Fabric-CA is a special certificate authority that provides a REST APIs for
    # dynamic certificate management (enroll, revoke, re-enroll). The following section is only for
    # Fabric-CA servers.
    certificateAuthorities:
      - ca.org1.example.com
    
    #users:
    #  Admin:
    #    cert:
    #      pem: ${FABRIC_SDK_GO_PROJECT_PATH}/fixtures/crypto-config/peerOrganizations/org1.example.com/users/Admin@org1.example.com/msp/tlsca/tlsca.org1.example.com-cert.pem



  # the profile will contain public information about organizations other than the one it belongs to.
  # These are necessary information to make transaction lifecycles work, including MSP IDs and
  # peers with a public URL to send transaction proposals. The file will not contain private
  # information reserved for members of the organization, such as admin key and certificate,
  # fabric-ca registrar enroll ID and secret, etc.
  Org2:
    mspid: Org2MSP
    cryptoPath: peerOrganizations/org2.example.com/users/{username}@org2.example.com/msp

    # Add peers for org2
    peers:
      - peer0.org2.example.com
      - peer1.org2.example.com
    certificateAuthorities:
      - ca.org2.example.com


  # Orderer Org name
  ordererorg:
    # Membership Service Provider ID for this organization
    mspID: OrdererMSP
    cryptoPath: ordererOrganizations/example.com/users/{username}@example.com/msp
    orderers:
      - orderer0.example.com
      - orderer1.example.com
      - orderer2.example.com


#
# List of orderers to send transaction and channel create/update requests to. For the time
# being only one orderer is needed. If more than one is defined, which one get used by the
# SDK is implementation specific. Consult each SDK's documentation for its handling of orderers.
#
orderers:
  orderer0.example.com:
    # [Optional] Default: Infer from hostname
    url: grpcs://localhost:7050

    # these are standard properties defined by the gRPC library
    # they will be passed in as-is to gRPC client constructor
    grpcOptions:
      ssl-target-name-override: orderer0.example.com
      keep-alive-time: 0s
      keep-alive-timeout: 20s
      keep-alive-permit: false
      fail-fast: false

      #will be taken into consideration if address has no protocol defined, if true then grpc or else grpcs
      allow-insecure: false

    tlsCACerts:
      # Certificate location absolute path
      # Replace to orderer cert path
      path: ${FABRIC_SDK_GO_PROJECT_PATH}/fixtures/crypto-config/ordererOrganizations/example.com/orderers/orderer0.example.com/msp/tlscacerts/tlsca.example.com-cert.pem

  orderer1.example.com:
    url: grpcs://localhost:8050
    grpcOptions:
      ssl-target-name-override: orderer1.example.com
      keep-alive-time: 0s
      keep-alive-timeout: 20s
      keep-alive-permit: false
      fail-fast: false
      allow-insecure: false
    tlsCACerts:
      path: ${FABRIC_SDK_GO_PROJECT_PATH}/fixtures/crypto-config/ordererOrganizations/example.com/orderers/orderer1.example.com/msp/tlscacerts/tlsca.example.com-cert.pem

  orderer2.example.com:
    url: grpcs://localhost:9050
    grpcOptions:
      ssl-target-name-override: orderer2.example.com
      keep-alive-time: 0s
      keep-alive-timeout: 20s
      keep-alive-permit: false
      fail-fast: false
      allow-insecure: false
    tlsCACerts:
      path: ${FABRIC_SDK_GO_PROJECT_PATH}/fixtures/crypto-config/ordererOrganizations/example.com/orderers/orderer2.example.com/msp/tlscacerts/tlsca.example.com-cert.pem

#
# List of peers to send various requests to, including endorsement, query
# and event listener registration.
#
peers:
  peer0.org1.example.com:
    # this URL is used to send endorsement and query requests
    # [Optional] Default: Infer from hostname
    # 表明使用grpcs协议，设置IP和端口号，使用域名会无法连接
    # url: grpcs://peer0.org1.example.com:7051
    url: grpcs://localhost:7051

    grpcOptions:
      ssl-target-name-override: peer0.org1.example.com
      keep-alive-time: 0s
      keep-alive-timeout: 20s
      keep-alive-permit: false
      fail-fast: false

      #will be taken into consideration if address has no protocol defined, if true then grpc or else grpcs
      allow-insecure: false

    tlsCACerts:
      # Certificate location absolute path
      path: ${FABRIC_SDK_GO_PROJECT_PATH}/fixtures/crypto-config/peerOrganizations/org1.example.com/tlsca/tlsca.org1.example.com-cert.pem

  peer1.org1.example.com:
    # this URL is used to send endorsement and query requests
    # [Optional] Default: Infer from hostname
    # 表明使用grpcs协议，设置IP和端口号，使用域名会无法连接
    # url: grpcs://peer0.org1.example.com:7051
    url: grpcs://localhost:8051
    grpcOptions:
      ssl-target-name-override: peer1.org1.example.com
      keep-alive-time: 0s
      keep-alive-timeout: 20s
      keep-alive-permit: false
      fail-fast: false

      #will be taken into consideration if address has no protocol defined, if true then grpc or else grpcs
      allow-insecure: false

    tlsCACerts:
      # Certificate location absolute path
      path: ${FABRIC_SDK_GO_PROJECT_PATH}/fixtures/crypto-config/peerOrganizations/org1.example.com/tlsca/tlsca.org1.example.com-cert.pem

  peer0.org2.example.com:
    # Replace the port
    url: grpcs://localhost:9051
    grpcOptions:
      ssl-target-name-override: peer0.org2.example.com
      keep-alive-time: 0s
      keep-alive-timeout: 20s
      keep-alive-permit: false
      fail-fast: false

      #will be taken into consideration if address has no protocol defined, if true then grpc or else grpcs
      allow-insecure: false
    tlsCACerts:
      path: ${FABRIC_SDK_GO_PROJECT_PATH}/fixtures/crypto-config/peerOrganizations/org2.example.com/tlsca/tlsca.org2.example.com-cert.pem

  peer1.org2.example.com:
    # Replace the port
    url: grpcs://localhost:10051
    grpcOptions:
      ssl-target-name-override: peer1.org2.example.com
      keep-alive-time: 0s
      keep-alive-timeout: 20s
      keep-alive-permit: false
      fail-fast: false

      #will be taken into consideration if address has no protocol defined, if true then grpc or else grpcs
      allow-insecure: false
    tlsCACerts:
      path: ${FABRIC_SDK_GO_PROJECT_PATH}/fixtures/crypto-config/peerOrganizations/org2.example.com/tlsca/tlsca.org2.example.com-cert.pem

# Fabric-CA is a special kind of Certificate Authority provided by Hyperledger Fabric which allows
# certificate management to be done via REST APIs. Application may choose to use a standard
# Certificate Authority instead of Fabric-CA, in which case this section would not be specified.
#
certificateAuthorities:
  ca.org1.example.com:
    url: http://localhost:7054
    tlsCACerts:
      # Certificate location absolute path
      path: ${FABRIC_SDK_GO_PROJECT_PATH}/fixtures/crypto-config/peerOrganizations/org1.example.com/ca/ca.org1.example.com-cert.pem
      # Client key and cert for SSL handshake with Fabric CA
      #client:
      #  key:
      #    path: /home/alextan/blockchain/fabric/fabric-samples-1.4/raft-local-test/crypto-config/peerOrganizations/tls.example.com/users/User1@tls.example.com/tls/client.key
      #  cert:
      #    path: /home/alextan/blockchain/fabric/fabric-samples-1.4/raft-local-test/crypto-config/peerOrganizations/tls.example.com/users/User1@tls.example.com/tls/client.crt
    # Fabric-CA supports dynamic user enrollment via REST APIs. A "root" user, a.k.a registrar, is
    # needed to enroll and invoke new users.
    registrar:
      enrollId: admin
      enrollSecret: adminpw
    # [Optional] The optional name of the CA.
    caName: ca.org1.example.com
  
  ca.org2.example.com:
    url: http://localhost:8054
    tlsCACerts:
      # Certificate location absolute path
      path: ${FABRIC_SDK_GO_PROJECT_PATH}/fixtures/crypto-config/peerOrganizations/org2.example.com/ca/ca.org2.example.com-cert.pem
      # Client key and cert for SSL handshake with Fabric CA
      #client:
      #  key:
      #    path: /home/alextan/blockchain/fabric/fabric-samples-1.4/raft-local-test/crypto-config/peerOrganizations/tls.example.com/users/User1@tls.example.com/tls/client.key
      #  cert:
      #    path: /home/alextan/blockchain/fabric/fabric-samples-1.4/raft-local-test/crypto-config/peerOrganizations/tls.example.com/users/User1@tls.example.com/tls/client.crt
    # Fabric-CA supports dynamic user enrollment via REST APIs. A "root" user, a.k.a registrar, is
    # needed to enroll and invoke new users.
    registrar:
      enrollId: admin
      enrollSecret: adminpw
    # [Optional] The optional name of the CA.
    caName: ca.org2.example.com

entitymatchers:
  peer:
    - pattern: (\w*)peer0.org1.example.com(\w*)
      urlsubstitutionexp: grpcs://localhost:7051
      ssltargetoverrideurlsubstitutionexp: peer0.org1.example.com
      mappedhost: peer0.org1.example.com

    - pattern: (\w*)peer1.org1.example.com(\w*)
      urlsubstitutionexp: grpcs://localhost:8051
      ssltargetoverrideurlsubstitutionexp: peer1.org1.example.com
      mappedhost: peer1.org1.example.com

    - pattern: (\w*)peer0.org2.example.com(\w*)
      urlsubstitutionexp: grpcs://localhost:9051
      ssltargetoverrideurlsubstitutionexp: peer0.org2.example.com
      mappedhost: peer0.org2.example.com

    - pattern: (\w*)peer1.org2.example.com(\w*)
      urlsubstitutionexp: grpcs://localhost:10051
      ssltargetoverrideurlsubstitutionexp: peer1.org2.example.com
      mappedhost: peer1.org2.example.com

  orderer:
    - pattern: (\w*)orderer0.example.com(\w*)
      urlsubstitutionexp: localhost:7050
      ssltargetoverrideurlsubstitutionexp: orderer0.example.com
      mappedhost: orderer0.example.com
    - pattern: (\w*)orderer1.example.com(\w*)
      urlsubstitutionexp: localhost:8050
      ssltargetoverrideurlsubstitutionexp: orderer1.example.com
      mappedhost: orderer1.example.com
    - pattern: (\w*)orderer2.example.com(\w*)
      urlsubstitutionexp: localhost:9050
      ssltargetoverrideurlsubstitutionexp: orderer2.example.com
      mappedhost: orderer2.example.com

  certificateAuthorities:
    - pattern: (\w*)ca.org1.example.com(\w*)
      urlSubstitutionExp: http://localhost:7054
      mappedHost: ca.org1.example.com
    
    - pattern: (\w*)ca.org2.example.com(\w*)
      urlSubstitutionExp: http://localhost:8054
      mappedHost: ca.org2.example.com

六、SDK实现

链码写好后，我们使用Fabric-SDK-Go提供的API来实现对链码的安装及实例化操作。

6.1 创建SDK

创建目录cli：

mkdir cli
cd cli
12

创建init.go文件

用于创建channel，加入channel:

/*
 * @Author: AlexTan
 * @GIthub: https://github.com/AlexTan-b-z
 * @Date: 2020-08-12 21:13:19
 * @LastEditors: AlexTan
 * @LastEditTime: 2020-08-12 22:07:26
 */

package cli

import (
	"log"

	"github.com/hyperledger/fabric-sdk-go/pkg/fabsdk"
	"github.com/hyperledger/fabric-sdk-go/pkg/core/config"
	"github.com/hyperledger/fabric-sdk-go/pkg/client/resmgmt"
	"github.com/hyperledger/fabric-sdk-go/pkg/common/errors/retry"
	"github.com/hyperledger/fabric-sdk-go/pkg/common/providers/msp"
	mspclient "github.com/hyperledger/fabric-sdk-go/pkg/client/msp"
)

const (
	org1CfgPath = "../../sdkConfig/org1_config.yaml"
	org2CfgPath = "../../sdkConfig/org2_config.yaml"

	channelConfig = "../../fixtures/channel-artifacts/channel.tx"
	ordererID = "orderer0.example.com"
	ordererOrgName = "ordererorg"
	org1Name = "Org1"
	org2Name = "Org2"
	orgAdmin = "Admin"
	channelID = "mychannel"
)

func CreateChannel(){
	sdk1, err := fabsdk.New(config.FromFile(org1CfgPath))
	if err != nil {
		log.Panicf("failed to create fabric sdk1: %s", err)
	}
	sdk2, err := fabsdk.New(config.FromFile(org2CfgPath))
	if err != nil {
		log.Panicf("failed to create fabric sdk2: %s", err)
	}

	clientContext := sdk1.Context(fabsdk.WithUser(orgAdmin), fabsdk.WithOrg(ordererOrgName))
	resMgmtClient, err := resmgmt.New(clientContext)
	if err != nil {
		log.Panicf("failed to create resMgmtClient in createChannel: %s", err)
	}

	mspClient, err := mspclient.New(sdk1.Context(), mspclient.WithOrg(org1Name))
	if err != nil {
		log.Panicf("failed to create msp client: %s", err)
	}
	adminIdentity, err := mspClient.GetSigningIdentity(orgAdmin)
	if err != nil {
		log.Panicf("failed to GetSigningIdentity: %s", err)
	}
	req := resmgmt.SaveChannelRequest{ChannelID: channelID,
		ChannelConfigPath: channelConfig,
		SigningIdentities: []msp.SigningIdentity{adminIdentity}}
		
	_, err = resMgmtClient.SaveChannel(req, resmgmt.WithRetry(retry.DefaultResMgmtOpts), resmgmt.WithOrdererEndpoint(ordererID))
	if err != nil {
		log.Panicf("failed to GetSigningIdentity: %s", err)
	}
	log.Println("created fabric channel")

	// join Channel
	org1Context := sdk1.Context(fabsdk.WithUser(orgAdmin), fabsdk.WithOrg(org1Name))
	org2Context := sdk2.Context(fabsdk.WithUser(orgAdmin), fabsdk.WithOrg(org2Name))

	org1ResMgmt, err := resmgmt.New(org1Context)
	if err != nil {
		log.Panicf("failed to create org1ResMgmt: %s", err)
	}
	org2ResMgmt, err := resmgmt.New(org2Context)
	if err != nil {
		log.Panicf("failed to create org2ResMgmt: %s", err)
	}
	if err = org1ResMgmt.JoinChannel(channelID, resmgmt.WithRetry(retry.DefaultResMgmtOpts), resmgmt.WithOrdererEndpoint(ordererID)); err != nil {
		log.Panicf("Org1 peers failed to JoinChannel: %s", err)
	}
	log.Println("org1 joined channel")
	if err = org2ResMgmt.JoinChannel(channelID, resmgmt.WithRetry(retry.DefaultResMgmtOpts), resmgmt.WithOrdererEndpoint(ordererID)); err != nil {
		log.Panicf("Org2 peers failed to JoinChannel: %s", err)
	}
	log.Println("org2 joined channel")
}

创建client.go，用于创建客户端:

/*
 * @Author: AlexTan
 * @GIthub: https://github.com/AlexTan-b-z
 * @Date: 2020-08-08 17:00:23
 * @LastEditors: AlexTan
 * @LastEditTime: 2020-08-12 21:57:18
 */
package cli

import (
	"log"
	"os"

	"github.com/hyperledger/fabric-sdk-go/pkg/client/channel"
	"github.com/hyperledger/fabric-sdk-go/pkg/client/resmgmt"
	"github.com/hyperledger/fabric-sdk-go/pkg/common/providers/fab"
	"github.com/hyperledger/fabric-sdk-go/pkg/core/config"
	"github.com/hyperledger/fabric-sdk-go/pkg/fabsdk"
)

type Client struct {
	// Fabric network information
	ConfigPath string
	OrgName    string
	OrgAdmin   string
	OrgUser    string

	// sdk clients
	SDK *fabsdk.FabricSDK
	rc  *resmgmt.Client
	cc  *channel.Client

	// for create channel
	// ChannelConfig string
	// OrdererID string
	
	
	// Same for each peer
	ChannelID string
	CCID      string // chaincode ID, eq name
	CCPath    string // chaincode source path, 是GOPATH下的某个目录
	CCGoPath  string // GOPATH used for chaincode
}

func New(cfg, org, admin, user string) *Client {
	c := &Client{
		ConfigPath: cfg,
		OrgName:    org,
		OrgAdmin:   admin,
		OrgUser:    user,
		// ChannelConfig: "../fixtures/channel-artifacts/channel.tx",
		// OrdererID: "orderer0.example.com",
		CCID:      "mycc",
		CCPath:    "chaincode/", // 相对路径是从GOPAHT/src开始的
		CCGoPath:  os.Getenv("GOPATH"),
		ChannelID: "mychannel",

	}

	// create sdk
	sdk, err := fabsdk.New(config.FromFile(c.ConfigPath))
	if err != nil {
		log.Panicf("failed to create fabric sdk: %s", err)
	}
	c.SDK = sdk
	log.Println("Initialized fabric sdk")

	c.rc, c.cc = NewSdkClient(sdk, c.ChannelID, c.OrgName, c.OrgAdmin, c.OrgUser)

	return c
}

// create channel
// func CreateChannel(sdk *fabsdk.FabricSDK, orgName, orgAdmin, channelID, ChannelConfig)

// NewSdkClient create resource client and channel client
func NewSdkClient(sdk *fabsdk.FabricSDK, channelID, orgName, orgAdmin, OrgUser string) (rc *resmgmt.Client, cc *channel.Client) {
	var err error

	// create rc
	rcp := sdk.Context(fabsdk.WithUser(orgAdmin), fabsdk.WithOrg(orgName))
	rc, err = resmgmt.New(rcp)
	if err != nil {
		log.Panicf("failed to create resource client: %s", err)
	}
	log.Println("Initialized resource client")

	// create cc
	ccp := sdk.ChannelContext(channelID, fabsdk.WithUser(OrgUser))
	cc, err = channel.New(ccp)
	if err != nil {
		log.Panicf("failed to create channel client: %s", err)
	}
	log.Println("Initialized channel client")

	return rc, cc
}

// RegisterChaincodeEvent more easy than event client to registering chaincode event.
func (c *Client) RegisterChaincodeEvent(ccid, eventName string) (fab.Registration, <-chan *fab.CCEvent, error) {
	return c.cc.RegisterChaincodeEvent(ccid, eventName)
}

创建chaincode.go

用于链码安装，实例化链码操作:

6.2 创建执行链码相关操作的文件

回到项目根目录

cd .. 
mkdir samples
cd samples
mkdir chaincode
1234

在samples/chaincode目录下创建文件main.go，用于运行链码相关操作:

/*
 * @Author: test1Tan
 * @GIthub: https://github.com/test1Tan-b-z
 * @Date: 2020-08-11 21:03:54
 * @LastEditors: AlexTan
 * @LastEditTime: 2020-08-19 20:20:44
 */
package main

import (
	"log"
	"time"

	"github.com/AlexTan-b-z/fabric-sdk-go-demo/cli"
	"github.com/AlexTan-b-z/fabric-sdk-go-demo/model"
)

const (
	org1CfgPath = "../../sdkConfig/org1_config.yaml"
	org2CfgPath = "../../sdkConfig/org2_config.yaml"
)

var (
	peer0Org1 = "peer0.org1.example.com"
	peer0Org2 = "peer0.org2.example.com"
)

func main() {

	// init
	// 第一次运行后记得注释掉
	cli.CreateChannel()

	org1Client := cli.New(org1CfgPath, "Org1", "Admin", "User1")
	org2Client := cli.New(org2CfgPath, "Org2", "Admin", "User1")

	defer org1Client.Close()
	defer org2Client.Close()

	// Install, instantiate, invoke, query
	Phase1(org1Client, org2Client)
	// Install, upgrade, invoke, query
	Phase2(org1Client, org2Client)
}

func Phase1(cli1, cli2 *cli.Client) {
	log.Println("=================== Phase 1 begin ===================")
	defer log.Println("=================== Phase 1 end ===================")

	if err := cli1.InstallCC("v1", peer0Org1); err != nil {
		log.Panicf("Intall chaincode error: %v", err)
	}
	log.Println("Chaincode has been installed on org1's peers")

	if err := cli2.InstallCC("v1", peer0Org2); err != nil {
		log.Panicf("Intall chaincode error: %v", err)
	}
	log.Println("Chaincode has been installed on org2's peers")

	// InstantiateCC chaincode only need once for each channel
	if _, err := cli1.InstantiateCC("v1", peer0Org1); err != nil {
		log.Panicf("Instantiated chaincode error: %v", err)
	}
	log.Println("Chaincode has been instantiated")

	sco1 := model.Score{
		Name: "test1",
		Gender: "男",
		StuID: "123",
		Grade: "2015",
		Result: "100",
		Time: time.Now().Format("2006-01-02 15:04:05"),
	}

	sco2 := model.Score{
		Name: "test2",
		Gender: "女",
		StuID: "1234",
		Grade: "2017",
		Result: "100",
		Time: time.Now().Format("2006-01-02 15:04:05"),
	}

	if _, err := cli1.InvokeCCadd([]string{peer0Org1}, sco1); err != nil {
		log.Panicf("InvokeCCadd test1 chaincode error: %v", err)
	}
	log.Println("InvokeCCadd test1 chaincode success 1")

	if _, err := cli1.InvokeCCadd([]string{peer0Org1}, sco2); err != nil {
		log.Panicf("InvokeCCadd test2 chaincode error: %v", err)
	}
	log.Println("InvokeCCadd test2 chaincode success 2")

	if err := cli1.QueryCCByNameAndGrade("peer0.org1.example.com", "test1", "2015"); err != nil {
		log.Panicf("QueryCCByNameAndGrade chaincode error: %v", err)
	}
	log.Println("QueryCCByNameAndGrade chaincode success on peer0.org1")

	if err := cli1.QueryCCByID("peer0.org1.example.com", "1234"); err != nil {
		log.Panicf("QueryCCByID chaincode error: %v", err)
	}
	log.Println("QueryCCByID chaincode success on peer0.org1")

	new_sco := model.Score{
		Name: "test1",
		Gender: "男",
		StuID: "123",
		Grade: "2015",
		Result: "99",
		Time: time.Now().Format("2006-01-02 15:04:05"),
	}
	if _, err := cli1.UpdateCCScore([]string{peer0Org1}, new_sco); err != nil {
		log.Panicf("updateCCScore chaincode error: %v", err)
	}
	log.Println("updateCCScore chaincode success 1")

	if err := cli1.QueryCCByID("peer0.org1.example.com", "123"); err != nil {
		log.Panicf("QueryCCByID chaincode error: %v", err)
	}
	log.Println("QueryCCByID chaincode success on peer0.org1")

	if _, err := cli1.InvokeCCDelete([]string{"peer0.org1.example.com"}, "123"); err != nil {
		log.Panicf("InvokeCCDelete chaincode error: %v", err)
	}
	log.Println("InvokeCCDelete chaincode success on peer0.org1")
}

func Phase2(cli1, cli2 *cli.Client) {
	log.Println("=================== Phase 2 begin ===================")
	defer log.Println("=================== Phase 2 end ===================")

	v := "v2"

	// Install new version chaincode
	if err := cli1.InstallCC(v, peer0Org1); err != nil {
		log.Panicf("Intall chaincode error: %v", err)
	}
	log.Println("Chaincode has been installed on org1's peers")

	if err := cli2.InstallCC(v, peer0Org2); err != nil {
		log.Panicf("Intall chaincode error: %v", err)
	}
	log.Println("Chaincode has been installed on org2's peers")

	// Upgrade chaincode only need once for each channel
	if err := cli1.UpgradeCC(v, peer0Org1); err != nil {
		log.Panicf("Upgrade chaincode error: %v", err)
	}
	log.Println("Upgrade chaincode success for channel")

	sco1 := model.Score{
		Name: "test3",
		Gender: "男",
		StuID: "12345",
		Grade: "2015",
		Result: "100",
		Time: time.Now().Format("2006-01-02 15:04:05"),
	}

	sco2 := model.Score{
		Name: "test4",
		Gender: "女",
		StuID: "123456",
		Grade: "2017",
		Result: "100",
		Time: time.Now().Format("2006-01-02 15:04:05"),
	}

	if _, err := cli1.InvokeCCadd([]string{"peer0.org1.example.com", "peer0.org2.example.com"}, sco1); err != nil {
		log.Panicf("InvokeCCadd test3 chaincode error: %v", err)
	}
	log.Println("InvokeCCadd test3 chaincode success 1")

	if _, err := cli1.InvokeCCadd([]string{peer0Org1, "peer0.org2.example.com"}, sco2); err != nil {
		log.Panicf("InvokeCCadd test4 chaincode error: %v", err)
	}
	log.Println("InvokeCCadd test4 chaincode success 2")

	if err := cli1.QueryCCByNameAndGrade("peer0.org2.example.com", "test3", "2015"); err != nil {
		log.Panicf("QueryCCByNameAndGrade chaincode error: %v", err)
	}
	log.Println("QueryCCByNameAndGrade chaincode success on peer0.org2")

	if err := cli1.QueryCCByID("peer0.org2.example.com", "12345"); err != nil {
		log.Panicf("QueryCCByID chaincode error: %v", err)
	}
	log.Println("QueryCCByID chaincode success on peer0.org2")

	new_sco := model.Score{
		Name: "test3",
		Gender: "男",
		StuID: "12345",
		Grade: "2015",
		Result: "99",
		Time: time.Now().Format("2006-01-02 15:04:05"),
	}
	if _, err := cli1.UpdateCCScore([]string{peer0Org1, "peer0.org2.example.com"}, new_sco); err != nil {
		log.Panicf("updateCCScore chaincode error: %v", err)
	}
	log.Println("updateCCScore chaincode success 1")

	if err := cli1.QueryCCByID("peer0.org2.example.com", "12345"); err != nil {
		log.Panicf("QueryCCByID chaincode error: %v", err)
	}
	log.Println("QueryCCByID chaincode success on peer0.org2")

	if _, err := cli1.InvokeCCDelete([]string{"peer0.org2.example.com", peer0Org1}, "12345"); err != nil {
		log.Panicf("InvokeCCDelete chaincode error: %v", err)
	}
	log.Println("InvokeCCDelete chaincode success on peer0.org2")
}

6.3 创建事件监听程序

回到前一个目录，创建event文件夹

cd ..
mkdir event
cd event
123

创建main.go，用于测试监听链码事件：

package main

import (
	"encoding/hex"
	"log"
	"time"

	"github.com/hyperledger/fabric-sdk-go/pkg/fab/events/deliverclient/seek"

	"github.com/hyperledger/fabric-sdk-go/pkg/client/event"
	"github.com/hyperledger/fabric-sdk-go/pkg/common/providers/fab"
	"github.com/hyperledger/fabric-sdk-go/pkg/fabsdk"
	
	"github.com/AlexTan-b-z/fabric-sdk-go-demo/cli"
	"github.com/AlexTan-b-z/fabric-sdk-go-demo/model"
)

const (
	org1CfgPath = "../../sdkConfig/org1_config.yaml"
	org2CfgPath = "../../sdkConfig/org2_config.yaml"
)

var (
	peer0Org1 = "peer0.org1.example.com"
	peer0Org2 = "peer0.org2.example.com"
)

func main() {
	org1Client := cli.New(org1CfgPath, "Org1", "Admin", "User1")
	org2Client := cli.New(org2CfgPath, "Org2", "Admin", "User1")
	defer org1Client.Close()
	defer org2Client.Close()

	// New event client
	cp := org1Client.SDK.ChannelContext(org1Client.ChannelID, fabsdk.WithUser(org1Client.OrgUser))

	ec, err := event.New(
		cp,
		event.WithBlockEvents(), // 如果没有，会是filtered
		// event.WithBlockNum(1), // 从指定区块获取，需要此参数
		event.WithSeekType(seek.Newest))
	if err != nil {
		log.Printf("Create event client error: %v", err)
	}

	// block event listen
	defer ec.Unregister(blockListener(ec))
	defer ec.Unregister(filteredBlockListener(ec))

	// tx listen
	txIDCh := make(chan string, 100)
	go txListener(ec, txIDCh)

	// chaincode event listen
	defer ec.Unregister(chainCodeEventListener(nil, ec))

	DoChainCode(org1Client, txIDCh)
	close(txIDCh)

	time.Sleep(time.Second * 10)
}

func blockListener(ec *event.Client) fab.Registration {
	// Register monitor block event
	beReg, beCh, err := ec.RegisterBlockEvent()
	if err != nil {
		log.Printf("Register block event error: %v", err)
	}
	log.Println("Registered block event")

	// Receive block event
	go func() {
		for e := range beCh {
			log.Printf("Receive block event:\nSourceURL: %v\nNumber: %v\nHash"+
				": %v\nPreviousHash: %v\n\n",
				e.SourceURL,
				e.Block.Header.Number,
				hex.EncodeToString(e.Block.Header.DataHash),
				hex.EncodeToString(e.Block.Header.PreviousHash))
		}
	}()

	return beReg
}

func filteredBlockListener(ec *event.Client) fab.Registration {
	// Register monitor filtered block event
	fbeReg, fbeCh, err := ec.RegisterFilteredBlockEvent()
	if err != nil {
		log.Printf("Register filtered block event error: %v", err)
	}
	log.Println("Registered filtered block event")

	// Receive filtered block event
	go func() {
		for e := range fbeCh {
			log.Printf("Receive filterd block event:\nNumber: %v\nlen("+
				"transactions): %v\nSourceURL: %v",
				e.FilteredBlock.Number, len(e.FilteredBlock.
					FilteredTransactions), e.SourceURL)

			for i, tx := range e.FilteredBlock.FilteredTransactions {
				log.Printf("tx index %d: type: %v, txid: %v, "+
					"validation code: %v", i,
					tx.Type, tx.Txid,
					tx.TxValidationCode)
			}
			log.Println() // Just go print empty log for easy to read
		}
	}()

	return fbeReg
}

func txListener(ec *event.Client, txIDCh chan string) {
	log.Println("Transaction listener start")
	defer log.Println("Transaction listener exit")

	for id := range txIDCh {
		// Register monitor transaction event
		log.Printf("Register transaction event for: %v", id)
		txReg, txCh, err := ec.RegisterTxStatusEvent(id)
		if err != nil {
			log.Printf("Register transaction event error: %v", err)
			continue
		}
		defer ec.Unregister(txReg)

		// Receive transaction event
		go func() {
			for e := range txCh {
				log.Printf("Receive transaction event: txid: %v, "+
					"validation code: %v, block number: %v",
					e.TxID,
					e.TxValidationCode,
					e.BlockNumber)
			}
		}()
	}
}

func chainCodeEventListener(c *cli.Client, ec *event.Client) fab.Registration {
	eventName := ".*"
	log.Printf("Listen chaincode event: %v", eventName)

	var (
		ccReg   fab.Registration
		eventCh <-chan *fab.CCEvent
		err     error
	)
	if c != nil {
		log.Println("Using client to register chaincode event")
		ccReg, eventCh, err = c.RegisterChaincodeEvent("mycc", eventName)
	} else {
		log.Println("Using event client to register chaincode event")
		ccReg, eventCh, err = ec.RegisterChaincodeEvent("mycc", eventName)
	}
	if err != nil {
		log.Printf("Register chaincode event error: %v", err.Error())
		return nil
	}

	// consume event
	go func() {
		for e := range eventCh {
			log.Printf("Receive cc event, ccid: %v \neventName: %v\n"+
				"payload: %v \ntxid: %v \nblock: %v \nsourceURL: %v\n",
				e.ChaincodeID, e.EventName, string(e.Payload), e.TxID, e.BlockNumber, e.SourceURL)
		}
	}()

	return ccReg
}

// Install、Deploy、Invoke、Query、Upgrade
func DoChainCode(cli1 *cli.Client, txCh chan<- string) {
	var (
		txid fab.TransactionID
		err  error
	)

	// ccVersion := "v1"
	// if err := cli1.InstallCC(ccVersion, peer0Org1); err != nil {
	// 	log.Panicf("Intall chaincode error: %v", err)
	// }
	// log.Println("Chaincode has been installed on org1's peers")
	//
	// // InstantiateCC chaincode only need once for each channel
	// if txid, err = cli1.InstantiateCC(ccVersion, peer0Org1); err != nil {
	// 	log.Panicf("Instantiated chaincode error: %v", err)
	// }
	// if txid != "" {
	// 	txCh <- string(txid)
	// }
	// log.Println("Chaincode has been instantiated")
	
	sco3 := model.Score{
		Name: "eventTest",
		Gender: "男",
		StuID: "888888",
		Grade: "2018",
		Result: "100",
		Time: time.Now().Format("2006-01-02 15:04:05"),
	}
	if txid, err = cli1.InvokeCCadd([]string{peer0Org1, "peer0.org2.example.com"}, sco3); err != nil {
		log.Panicf("InvokeCCadd chaincode error: %v", err)
	}
	log.Println("InvokeCCadd chaincode success 1")
	if txid != "" {
		txCh <- string(txid)
	}
	log.Println("Invoke chaincode success")

	if err = cli1.QueryCCByID("peer0.org1.example.com", "888888"); err != nil {
		log.Panicf("Query chaincode error: %v", err)
	}
	log.Println("Query chaincode success on peer0.org1")

	if txid, err = cli1.InvokeCCDelete([]string{"peer0.org1.example.com", "peer0.org2.example.com"}, "888888"); err != nil {
		log.Panicf("InvokeCCDelete chaincode error: %v", err)
	}
}

七、测试运行

确保已经启动好容器环境后，分别运行samples/chaincode/main.go和samples/event/main.go即可完成测试。

其中包括以下操作：

  • 创建通道
  • 把org1、org2（所有节点）加入通道
  • 在指定节点安装链码
  • 实例化链码（配置背书策略）
  • 调用链码
  • 更新链码背书策略
  • 调用新的链码（新的背书策略）
  • 清理环境

清理环境

要清理运行环境，使用docker-compose将容器停掉并移除即可：

docker-compose -f docker-compose-local.yaml down -v
乐观的阿锡
关注
  • 2
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
fabric-sdk-go与GIN框架应用.pdf
03-23
fabric-sdk-go与GIN框架应用
Hyperledger fabric介绍之fabric-sdk-go入门
最新发布
qq_65114400的博客
01-16 1280
Fabric SDK Go是用于与Hyperledger Fabric网络进行交互的Go语言软件开发工具包（SDK）。它提供了一组功能强大的API和工具，使开发人员能够构建基于Fabric的应用程序、执行交易、查询状态、管理身份等。
【Fabric】教程之使用GO-SDK(一）
Moooonk的博客
09-02 3235
整个目录可以分为三个部分，即fabric相关，app相关；其中app分为server后端和web前端。故创建如下文件夹：fixture、app/server和app/web。
Fabric-sdk-java 新增组织
Edgar_LQS的博客
05-23 659
fabric-sdk-java新增组织
fabric2.2.0中使用fabric-sdk-java 2.2.0 创建channel,添加peer.
weixin_42528678的博客
11-26 1万+
在进行fabric-sdk-java 2.2.0的学习中,在进行创建channel和添加peer的过程,网上能查到的资料很少并且还不全面,在这边我根据官方给的测试案例和自己的研究,成功的完成了这个过程,下面进行一些总结和代码的展示, 参考案例地址:https://github.com/hyperledger/fabric-sdk-java/blob/release-2.2/src/test/java/org/hyperledger/fabric/sdkintegration/End2endLifecy..
fabric-sdk-go的搭建过程总结
weixin_45270330的博客
04-14 1566
fabric的cli自动化 sdk-go
fabric-sdk-py:Hyperledger Fabric Python SDK
05-04
面料-SDK-Py Fabric-SDK-Py是Hyperledger Fabric SDK的Python 3.x实现！ 当前，它主要支持Fabric 1.4.x版本。前提条件该SDK需要Python3和Libssl pkgs。 如果没有，请运行以下cmd来安装必备组件： 作业系统命令Ubuntu...
fabric-java-sdk-demo.zip
09-02
《基于Fabric-Java-SDK的区块链应用实践》 在当今的数字时代，区块链技术作为一种分布式账本技术，正逐渐渗透到各个行业中。Hyperledger Fabric，作为Linux基金会主导的开源项目，是企业级区块链解决方案的重要代表...
fabric2.x的api的服务（基于fabric go sdk）
04-05
Fabric Go SDK是Hyperledger Fabric项目提供的官方开发工具，用于用Go语言编写应用，与Fabric网络进行交互。它包括了与Orderer、Peers、Channels和Chaincode通信所需的模块和接口。 2. **API服务核心组件** - **...
fabric-sdk-go.zip
04-02
go客户端
fabric-SDK-go初探
weixin_44336181的博客
07-27 1667
一.概述 Farbric的Peer节点和Orderer节点都提供了基于GRPC协议(Google开发的远程过程调用RPC)的接口，通过这些接口可以和Peer节点与Orderer节点进行命令/数据交互，为了简化开发，官方提供了多语言版本的SDK 考虑到Golang是Fabric原生的开发语言，Fabric，Fabric-ca,Chaincode都是采用Golang开发的，所以个人还是倾向于学习使用Golang版本的Fabric SDK。 二.安装环境 本文测试环境在mac OS上，在Linux与windows
Hyperledger Fabric 智能合约开发及 fabric-sdk-go/fabric-gateway 使用示例
热门推荐
风色幻想的博客
06-11 3万+
在上个实验 Hyperledger Fabric 多组织多排序节点部署在多个主机上 中，我们已经实现了多组织多排序节点部署在多个主机上，但到目前为止，我们所有的实验都只是研究了联盟链的网络配置方法（尽管这确实是重难点），而没有考虑具体的应用开发。本文将在前面实验的基础上，首先尝试使用 Go 语言开发了一个工作室联盟链的项目信息智能合约，并成功将其部署至联盟链上；然后依据官方示例，使用 fabric-gateway 模块实现了一个能够管理项目信息智能合约的客户端；之后对比了 fabric-gateway 模块
go get 指定版本_fabric-sdk-go快速入门教程
weixin_39760689的博客
11-30 416
fabric-sdk-go是Hyperledger Fabric官方提供的Go语言开发包， 应用程序可以利用fabric-sdk-go与fabric网络进行交互并访问链码。 本教程介绍如何使用fabric-sdk-go实现链码的安装、实例化、交易提交 和状态查询等操作。Hyperledger Fabric区块链开发教程： Fabric Node.js开发详解 | Fabric Java开发详解 |...
Fabric-SDK-Go
星回昭以烂的博客
06-30 4484
Fabric-SDK-Go 1.配置Fabric-SDK 1）创建config.yaml 确认 Hyperledger Fabric 基础网络环境运行没有问题后，现在我们通过创建一个新的 config.yaml 配置文件给应用程序所使用的 Fabric-SDK-Go 配置相关参数及 Fabric 组件的通信地址 进入项目的根目录中创建一个 config.yaml 文件并编辑 2）定义所需结构体 配置文件完成指定的配置信息之后，我们开始编写代码。 在项目的根目录下添加一个名为 sdkInit 的新目录，我们将
Hyperledger fabric2.4 fabric-SDK-GO开发
qq_28052455的博客
09-12 4315
在实际部署时，一般将Fabric SDK作为API到提供者，为上层应用或对外服务提供Fabric区块链网络底层服务。Fabric SDK本质是一个Fabric基础对象，功能的封装集合和客户端框架实现，旨在方便开发人员快速开发出符合产品业务需求的服务模块。获取 Fabric 和 Fabric CA 的客户端 SDK 包，SDK 文档可以在下面使用sdk实现创建通道，加入通道，打包链码，安装链码，升级链码等功能。
Hyperledger fabric-SDK-GO客户端开发
weixin_40618306的博客
11-06 1266
Hyperledger fabric-SDK-GO客户端开发 Fabric-SDK-GO时提供 的Go语言开发包，应用程序可以利用Fabric-SDK-GO与Fabric网络进行交互并访问链码。 1.1目录介绍 pkg目录是fabric go sdk的主要实现，doc文档介绍了不同目录所提供的功能，以及给出了接口调用案例： pkg/fabsdk:主package，主要用来 生成fabsdk以及fabric go sdk中其他pkg使用的option context。 pkg/client/channel
使用fabric-sdk-go调用Fabric 1.4 BYFN中的链码
TrueTechLabs 官方博客
12-24 1607
使用fabric-sdk-go调用BYFN中的链码，简明好用
fabric-sdk-go和fabric一同食用，换包的那些坑
oe1019的专栏
03-23 1527
最近在帮着完善基于grpc的fabric性能测试工具，https://github.com/guoger/stupid 其中遇到一个坑就是在fabric 1.4.4之后，fabric重构了git上的项目结构和依赖关系。 首先最大的一个痛点就是proto的位置换掉了。这里导致了一个间接的问题，就是在golang里fabric proto如果biuld两次会出现 msp枚举类型被覆盖的错误。 ...
fabric1.4 go sdk 示例
qq_17668519的博客
05-24 3104
首先把这个例子 跑起来 https://hyperledger-fabric.readthedocs.io/en/release-1.4/build_network.html# 成功之后 然后执行 ./byfn.sh down 关闭这个网络 下面开始搭建 基础环境 这些命令 都在 fabric-samples/first-network 这个目录下 执行 export FABRIC_CFG_P...
fabric-sdk-go + gin
04-28
fabric-sdk-go和gin是两个不同的开源项目。 fabric-sdk-go是Hyperledger Fabric的一个官方SDK，它提供了一系列的API和工具，用于方便地与Fabric网络进行交互。它是基于Golang开发，具有高效、稳定和可扩展性强等优点。通过使用fabric-sdk-go，开发者可以轻松地构建自己的Fabric网络应用程序。 gin是一个轻量级的Web框架，也是基于Golang开发的。它具有高性能、易用性和灵活性等特点。借助gin，你可以快速地开发出高效的Web应用程序。gin是一种非常受欢迎的Web框架，它拥有大量的用户和开发者。同时，gin也是一个开源项目，你可以自由地使用和修改它。 由于fabric-sdk-go和gin是两个不同的项目，它们之间并没有直接的关联。不过，在一些项目中，你可能需要同时使用fabric-sdk-go和gin。例如，你可能需要使用fabric-sdk-go与Fabric网络交互，同时使用gin来提供Web服务。在这种情况下，我们可以将它们集成到一起，以便更好地满足我们的需求。但是这需要开发者们自己来实现。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值