AI 助理
备案控制台
开发者社区 安全 文章 正文

区块链教程Fabric1.0源代码分析Peer peer node start命令实现-兄弟连区块链

2018-11-05 1299
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介：

　　兄弟连区块链教程Fabric1.0源代码分析Peer peer node start命令实现，2018年下半年，区块链行业正逐渐褪去发展之初的浮躁、回归理性，表面上看相关人才需求与身价似乎正在回落。但事实上，正是初期泡沫的渐退，让人们更多的关注点放在了区块链真正的技术之上。

Fabric 1.0源代码笔记 之 Peer #peer node start命令实现

_2

1、peer node加载子命令start和status

peer node加载子命令start和status，代码如下：

func Cmd() *cobra.Command {
    nodeCmd.AddCommand(startCmd()) //加载子命令start
    nodeCmd.AddCommand(statusCmd()) //加载子命令status
    return nodeCmd
}

var nodeCmd = &cobra.Command{
    Use:   nodeFuncName,
    Short: fmt.Sprint(shortDes),
    Long:  fmt.Sprint(longDes),
}
//代码在peer/node/node.go

startCmd()代码如下：
其中serve(args)为peer node start的实现代码，比较复杂，本文将重点讲解。
另statusCmd()代码与startCmd()相近，暂略。

func startCmd() *cobra.Command {
    flags := nodeStartCmd.Flags()
    flags.BoolVarP(&chaincodeDevMode, "peer-chaincodedev", "", false, "Whether peer in chaincode development mode")
    flags.BoolVarP(&peerDefaultChain, "peer-defaultchain", "", false, "Whether to start peer with chain testchainid")
    flags.StringVarP(&orderingEndpoint, "orderer", "o", "orderer:7050", "Ordering service endpoint") //orderer
    return nodeStartCmd
}

var nodeStartCmd = &cobra.Command{
    Use:   "start",
    Short: "Starts the node.",
    Long:  `Starts a node that interacts with the network.`,
    RunE: func(cmd *cobra.Command, args []string) error {
        return serve(args) //serve(args)为peer node start的实现代码
    },
}
//代码在peer/node/start.go

注：如下内容均为serve(args)的代码，即peer node start命令执行流程。

2、初始化Ledger（账本）

初始化账本，即如下一条代码：

ledgermgmt.Initialize()
//代码在peer/node/start.go

ledgermgmt.Initialize()代码展开如下：

func initialize() {
    openedLedgers = make(map[string]ledger.PeerLedger) //openedLedgers为全局变量，存储目前使用的账本列表
    provider, err := kvledger.NewProvider() //创建账本Provider实例
    ledgerProvider = provider
}
//代码在core/ledger/ledgermgmt/ledger_mgmt.go

kvledger.NewProvider()代码如下：

func NewProvider() (ledger.PeerLedgerProvider, error) {
    idStore := openIDStore(ledgerconfig.GetLedgerProviderPath()) //打开idStore

    //创建并初始化blkstorage
    attrsToIndex := []blkstorage.IndexableAttr{
        blkstorage.IndexableAttrBlockHash,
        blkstorage.IndexableAttrBlockNum,
        blkstorage.IndexableAttrTxID,
        blkstorage.IndexableAttrBlockNumTranNum,
        blkstorage.IndexableAttrBlockTxID,
        blkstorage.IndexableAttrTxValidationCode,
    }
    indexConfig := &blkstorage.IndexConfig{AttrsToIndex: attrsToIndex}
    blockStoreProvider := fsblkstorage.NewProvider(
        fsblkstorage.NewConf(ledgerconfig.GetBlockStorePath(), ledgerconfig.GetMaxBlockfileSize()),
        indexConfig)

    //创建并初始化statedb
    var vdbProvider statedb.VersionedDBProvider
    if !ledgerconfig.IsCouchDBEnabled() {
        vdbProvider = stateleveldb.NewVersionedDBProvider()
    } else {
        vdbProvider, err = statecouchdb.NewVersionedDBProvider()
    }

    //创建并初始化historydb
    var historydbProvider historydb.HistoryDBProvider
    historydbProvider = historyleveldb.NewHistoryDBProvider()
    //构造Provider
    provider := &Provider{idStore, blockStoreProvider, vdbProvider, historydbProvider}
    provider.recoverUnderConstructionLedger()
    return provider, nil
}
//代码在core/ledger/kvledger/kv_ledger_provider.go

Ledger更详细内容，参考：Fabric 1.0源代码笔记 之 Ledger（账本）

3、配置及创建PeerServer、创建EventHubServer（事件中心服务器）

//初始化全局变量localAddress和peerEndpoint
err := peer.CacheConfiguration() 
peerEndpoint, err := peer.GetPeerEndpoint() //获取peerEndpoint
listenAddr := viper.GetString("peer.listenAddress") //PeerServer监听地址
secureConfig, err := peer.GetSecureConfig() //获取PeerServer安全配置，是否启用TLS、公钥、私钥、根证书
//以监听地址和安全配置，创建Peer GRPC Server
peerServer, err := peer.CreatePeerServer(listenAddr, secureConfig)
//创建EventHubServer（事件中心服务器）
ehubGrpcServer, err := createEventHubServer(secureConfig)
//代码在peer/node/start.go

func createEventHubServer(secureConfig comm.SecureServerConfig) (comm.GRPCServer, error)代码如下：

var lis net.Listener
var err error
lis, err = net.Listen("tcp", viper.GetString("peer.events.address")) //创建Listen
grpcServer, err := comm.NewGRPCServerFromListener(lis, secureConfig) //从Listen创建GRPCServer
ehServer := producer.NewEventsServer(
    uint(viper.GetInt("peer.events.buffersize")), //最大进行缓冲的消息数
    viper.GetDuration("peer.events.timeout")) //缓冲已满的情况下，往缓冲中发送消息的超时
pb.RegisterEventsServer(grpcServer.Server(), ehServer) //EventHubServer注册至grpcServer
return grpcServer, nil
//代码在peer/node/start.go

pb.RegisterEventsServer(grpcServer.Server(), ehServer)代码如下：

func RegisterEventsServer(s *grpc.Server, srv EventsServer) {
    s.RegisterService(&_Events_serviceDesc, srv) 
}
//代码在protos/peer/events.pb.go

events（事件服务）更详细内容，参考：Fabric 1.0源代码笔记 之 events（事件服务）

4、创建并启动Chaincode Server，并注册系统链码

代码如下：

ccprovider.EnableCCInfoCache() //ccInfoCacheEnabled = true
//创建Chaincode Server
//如果peer.chaincodeListenAddress，没有定义或者定义和peerListenAddress相同，均直接使用peerServer
//否则另行创建NewGRPCServer用于Chaincode Server
ccSrv, ccEpFunc := createChaincodeServer(peerServer, listenAddr)
//Chaincode service注册到grpcServer，并注册系统链码
registerChaincodeSupport(ccSrv.Server(), ccEpFunc)
go ccSrv.Start() //启动grpcServer
//代码在peer/node/start.go

ccSrv, ccEpFunc := createChaincodeServer(peerServer, listenAddr)代码如下：创建Chaincode Server。

func createChaincodeServer(peerServer comm.GRPCServer, peerListenAddress string) (comm.GRPCServer, ccEndpointFunc) {
    //peer.chaincodeListenAddress，链码容器连接时的监听地址
    cclistenAddress := viper.GetString("peer.chaincodeListenAddress")

    var srv comm.GRPCServer
    var ccEpFunc ccEndpointFunc
    
    //如果peer.chaincodeListenAddress，没有定义或者定义和peerListenAddress相同，均直接使用peerServer
    //否则另行创建NewGRPCServer用于Chaincode Server
    if cclistenAddress == "" {
        ccEpFunc = peer.GetPeerEndpoint
        srv = peerServer
    } else if cclistenAddress == peerListenAddress {
        ccEpFunc = peer.GetPeerEndpoint
        srv = peerServer
    } else {
        config, err := peer.GetSecureConfig()
        srv, err = comm.NewGRPCServer(cclistenAddress, config)
        ccEpFunc = getChaincodeAddressEndpoint
    }

    return srv, ccEpFunc
}
//代码在peer/node/start.go

registerChaincodeSupport(ccSrv.Server(), ccEpFunc)代码如下：Chaincode service注册到grpcServer。

func registerChaincodeSupport(grpcServer *grpc.Server, ccEpFunc ccEndpointFunc) {
    userRunsCC := chaincode.IsDevMode() //是否开发模式
    ccStartupTimeout := viper.GetDuration("chaincode.startuptimeout") //启动链码容器的超时
    if ccStartupTimeout < time.Duration(5)*time.Second { //至少5秒
        ccStartupTimeout = time.Duration(5) * time.Second
    } else {
    }
    //构造ChaincodeSupport
    ccSrv := chaincode.NewChaincodeSupport(ccEpFunc, userRunsCC, ccStartupTimeout)
    scc.RegisterSysCCs() //注册系统链码
    pb.RegisterChaincodeSupportServer(grpcServer, ccSrv) //service注册到grpcServer
}
//代码在peer/node/start.go

ccSrv := chaincode.NewChaincodeSupport(ccEpFunc, userRunsCC, ccStartupTimeout)代码如下：构造ChaincodeSupport。

var theChaincodeSupport *ChaincodeSupport

func NewChaincodeSupport(getCCEndpoint func() (*pb.PeerEndpoint, error), userrunsCC bool, ccstartuptimeout time.Duration) *ChaincodeSupport {
    //即/var/hyperledger/production/chaincodes
    ccprovider.SetChaincodesPath(config.GetPath("peer.fileSystemPath") + string(filepath.Separator) + "chaincodes")

    pnid := viper.GetString("peer.networkId") //网络ID
    pid := viper.GetString("peer.id") //节点ID

    //构造ChaincodeSupport
    theChaincodeSupport = &ChaincodeSupport{runningChaincodes: &runningChaincodes{chaincodeMap: make(map[string]*chaincodeRTEnv), launchStarted: make(map[string]bool)}, peerNetworkID: 
pnid, peerID: pid}

    ccEndpoint, err := getCCEndpoint() //此处传入ccEpFunc
    if err != nil {
        theChaincodeSupport.peerAddress = viper.GetString("chaincode.peerAddress")
    } else {
        theChaincodeSupport.peerAddress = ccEndpoint.Address
    }
    if theChaincodeSupport.peerAddress == "" {
        theChaincodeSupport.peerAddress = peerAddressDefault
    }

    theChaincodeSupport.userRunsCC = userrunsCC //是否开发模式
    theChaincodeSupport.ccStartupTimeout = ccstartuptimeout //启动链码容器的超时

    theChaincodeSupport.peerTLS = viper.GetBool("peer.tls.enabled") //是否启用TLS
    if theChaincodeSupport.peerTLS {
        theChaincodeSupport.peerTLSCertFile = config.GetPath("peer.tls.cert.file")
        theChaincodeSupport.peerTLSKeyFile = config.GetPath("peer.tls.key.file")
        theChaincodeSupport.peerTLSSvrHostOrd = viper.GetString("peer.tls.serverhostoverride")
    }

    kadef := 0
    // Peer和链码之间的心跳超时，小于或等于0意味着关闭
    if ka := viper.GetString("chaincode.keepalive"); ka == "" {
        theChaincodeSupport.keepalive = time.Duration(kadef) * time.Second //0
    } else {
        t, terr := strconv.Atoi(ka)
        if terr != nil {
            t = kadef //0
        } else if t <= 0 {
            t = kadef //0
        }
        theChaincodeSupport.keepalive = time.Duration(t) * time.Second //非0
    }

    execto := time.Duration(30) * time.Second
    //invoke和initialize命令执行超时
    if eto := viper.GetDuration("chaincode.executetimeout"); eto <= time.Duration(1)*time.Second {
        //小于1秒时，默认30秒
    } else {
        execto = eto
    }
    theChaincodeSupport.executetimeout = execto

    viper.SetEnvPrefix("CORE")
    viper.AutomaticEnv()
    replacer := strings.NewReplacer(".", "_")
    viper.SetEnvKeyReplacer(replacer)

    theChaincodeSupport.chaincodeLogLevel = getLogLevelFromViper("level")
    theChaincodeSupport.shimLogLevel = getLogLevelFromViper("shim")
    theChaincodeSupport.logFormat = viper.GetString("chaincode.logging.format")

    return theChaincodeSupport
}

//代码在core/chaincode/chaincode_support.go

scc.RegisterSysCCs()代码如下：注册系统链码。

func RegisterSysCCs() {
    //cscc、lscc、escc、vscc、qscc
    for _, sysCC := range systemChaincodes {
        RegisterSysCC(sysCC)
    }
}
代码在core/scc/importsysccs.go

5、注册Admin server和Endorser server

代码如下：

//s.RegisterService(&_Admin_serviceDesc, srv)
//var _Admin_serviceDesc = grpc.ServiceDesc{...}
//core.NewAdminServer()构造ServerAdmin结构体，ServerAdmin结构体实现type AdminServer interface接口
pb.RegisterAdminServer(peerServer.Server(), core.NewAdminServer())
//构造结构体Endorser，Endorser结构体实现type EndorserServer interface接口
serverEndorser := endorser.NewEndorserServer()
//s.RegisterService(&_Endorser_serviceDesc, srv)
//var _Endorser_serviceDesc = grpc.ServiceDesc{...}
pb.RegisterEndorserServer(peerServer.Server(), serverEndorser)
//代码在peer/node/start.go

附type AdminServer interface接口定义：

type AdminServer interface {
    GetStatus(context.Context, *google_protobuf.Empty) (*ServerStatus, error)
    StartServer(context.Context, *google_protobuf.Empty) (*ServerStatus, error)
    GetModuleLogLevel(context.Context, *LogLevelRequest) (*LogLevelResponse, error)
    SetModuleLogLevel(context.Context, *LogLevelRequest) (*LogLevelResponse, error)
    RevertLogLevels(context.Context, *google_protobuf.Empty) (*google_protobuf.Empty, error)
}
//代码在protos/peer/admin.pb.go

附type EndorserServer interface接口定义：

type EndorserServer interface {
    ProcessProposal(context.Context, *SignedProposal) (*ProposalResponse, error)
}
//代码在protos/peer/peer.pb.go

6、初始化Gossip服务

bootstrap := viper.GetStringSlice("peer.gossip.bootstrap") //启动节点后gossip连接的初始节点
serializedIdentity, err := mgmt.GetLocalSigningIdentityOrPanic().Serialize() //获取签名身份
messageCryptoService := peergossip.NewMCS( //构造mspMessageCryptoService（消息加密服务）
    peer.NewChannelPolicyManagerGetter(), //构造type channelPolicyManagerGetter struct{}
    localmsp.NewSigner(), //构造type mspSigner struct {}
    mgmt.NewDeserializersManager()) //构造type mspDeserializersManager struct{}
secAdv := peergossip.NewSecurityAdvisor(mgmt.NewDeserializersManager()) //构造mspSecurityAdvisor（安全顾问）

secureDialOpts := func() []grpc.DialOption {
    var dialOpts []grpc.DialOption
    dialOpts = append(dialOpts, grpc.WithDefaultCallOptions(grpc.MaxCallRecvMsgSize(comm.MaxRecvMsgSize()), //MaxRecvMsgSize
        grpc.MaxCallSendMsgSize(comm.MaxSendMsgSize()))) //MaxSendMsgSize
    dialOpts = append(dialOpts, comm.ClientKeepaliveOptions()...) //ClientKeepaliveOptions
        
    if comm.TLSEnabled() {
        tlsCert := peerServer.ServerCertificate()
        dialOpts = append(dialOpts, grpc.WithTransportCredentials(comm.GetCASupport().GetPeerCredentials(tlsCert)))
    } else {
        dialOpts = append(dialOpts, grpc.WithInsecure())
    }
    return dialOpts
}

err = service.InitGossipService(serializedIdentity, peerEndpoint.Address, peerServer.Server(),
    messageCryptoService, secAdv, secureDialOpts, bootstrap...) //构造gossipServiceImpl
defer service.GetGossipService().Stop()
//代码在peer/node/start.go

Gossip更详细内容参考：Fabric 1.0源代码笔记 之 gossip（流言算法）

7、初始化、部署并执行系统链码（scc）

代码如下：

initSysCCs() //初始化系统链码，调用scc.DeploySysCCs("")
peer.Initialize(func(cid string) { //初始化所有链
    scc.DeploySysCCs(cid) //按chain id部署并运行系统链码
})
//代码在peer/node/start.go

func Initialize(init func(string))代码如下：

func Initialize(init func(string)) {
    chainInitializer = init

    var cb *common.Block
    var ledger ledger.PeerLedger
    ledgermgmt.Initialize()
    ledgerIds, err := ledgermgmt.GetLedgerIDs()
    for _, cid := range ledgerIds {
        ledger, err = ledgermgmt.OpenLedger(cid)
        cb, err = getCurrConfigBlockFromLedger(ledger) //获取最新的配置块
        err = createChain(cid, ledger, cb)
        InitChain(cid) //即调用chainInitializer(cid)，即scc.DeploySysCCs(cid)
    }
}
//代码在core/peer/peer.go

createChain(cid, ledger, cb)代码如下：

func createChain(cid string, ledger ledger.PeerLedger, cb *common.Block) error {
    envelopeConfig, err := utils.ExtractEnvelope(cb, 0) //获取配置交易
    configtxInitializer := configtx.NewInitializer() //构造initializer
    gossipEventer := service.GetGossipService().NewConfigEventer() //获取gossipServiceInstance，并构造configEventer

    gossipCallbackWrapper := func(cm configtxapi.Manager) {
        ac, ok := configtxInitializer.ApplicationConfig()
        gossipEventer.ProcessConfigUpdate(&chainSupport{
            Manager:     cm,
            Application: ac,
        })
        //验证可疑节点身份，并关闭无效链接
        service.GetGossipService().SuspectPeers(func(identity api.PeerIdentityType) bool {
            return true
        })
    }

    trustedRootsCallbackWrapper := func(cm configtxapi.Manager) {
        updateTrustedRoots(cm)
    }

    configtxManager, err := configtx.NewManagerImpl(
        envelopeConfig,
        configtxInitializer,
        []func(cm configtxapi.Manager){gossipCallbackWrapper, trustedRootsCallbackWrapper},
    )
    mspmgmt.XXXSetMSPManager(cid, configtxManager.MSPManager())

    ac, ok := configtxInitializer.ApplicationConfig()
    cs := &chainSupport{
        Manager:     configtxManager,
        Application: ac, // TODO, refactor as this is accessible through Manager
        ledger:      ledger,
    }

    c := committer.NewLedgerCommitterReactive(ledger, txvalidator.NewTxValidator(cs), func(block *common.Block) error {
        chainID, err := utils.GetChainIDFromBlock(block)
        if err != nil {
            return err
        }
        return SetCurrConfigBlock(block, chainID)
    })

    ordererAddresses := configtxManager.ChannelConfig().OrdererAddresses()
    service.GetGossipService().InitializeChannel(cs.ChainID(), c, ordererAddresses)

    chains.Lock()
    defer chains.Unlock()
    chains.list[cid] = &chain{
        cs:        cs,
        cb:        cb,
        committer: c,
    }
    return nil
}
//代码在core/peer/peer.go

scc更详细内容参考：Fabric 1.0源代码笔记 之 scc（系统链码）

8、启动peerServer和ehubGrpcServer，并监控系统信号，以及启动Go自带的profiling支持进行调试

代码如下：

serve := make(chan error)
sigs := make(chan os.Signal, 1)
signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)

go func() {
    sig := <-sigs //接收系统信号
    serve <- nil
}

go func() {
    var grpcErr error
    grpcErr = peerServer.Start() //启动peerServer
    serve <- grpcErr
}

err := writePid(config.GetPath("peer.fileSystemPath")+"/peer.pid", os.Getpid()) //写入pid

go ehubGrpcServer.Start() //启动ehubGrpcServer

if viper.GetBool("peer.profile.enabled") {
    go func() { //启动Go自带的profiling支持进行调试
        profileListenAddress := viper.GetString("peer.profile.listenAddress")
        profileErr := http.ListenAndServe(profileListenAddress, nil)
    }
}

return <-serve //等待serve
//代码在peer/node/start.go

9、按配置文件重新更新模块日志级别

overrideLogModules := []string{"msp", "gossip", "ledger", "cauthdsl", "policies", "grpc"}
for _, module := range overrideLogModules {
    err = common.SetLogLevelFromViper(module)
}
flogging.SetPeerStartupModulesMap()
//代码在peer/node/start.go
文章标签：
超级计算集群
Go
区块链
容器
前端开发
监控
数据安全/隐私保护
网络协议
安全
算法
存储
关键词：
分析node.js
node.js命令
区块链分析
Fabric node
Fabric命令
区块链教程
目录
相关文章
开发V_I357O98O7I8
|
7月前
|
安全 区块链
区块链积分商城系统开发详细指南//需求功能/指南教程/源码流程
Developing a blockchain points mall system involves multiple aspects such as blockchain technology, smart contracts, front-end development, and business logic design. The following is the general process for developing a blockchain points mall system
开发V_I357O98O7I8
129 1
SarPro
|
7月前
|
Web App开发 缓存 JavaScript
【安装指南】nodejs下载、安装与配置详细教程
这篇博文详细介绍了 Node.js 的下载、安装与配置过程，为初学者提供了清晰的指南。读者通过该教程可以轻松完成 Node.js 的安装，了解相关配置和基本操作。文章首先介绍了 Node.js 的背景和应用场景，随后详细说明了下载安装包、安装步骤以及配置环境变量的方法。作者用简洁明了的语言，配以步骤图示，使得读者能够轻松跟随教程完成操作。总的来说，这篇文章为初学者提供了一个友好的入门指南，使他们能够顺利开始使用 Node.js 进行开发。
SarPro
1394 2
【安装指南】nodejs下载、安装与配置详细教程
爱喝汤的技术少年
|
7月前
|
JavaScript 前端开发 网络协议
​Node.js 教程(一) 基本概念与基本使用
​Node.js 教程(一) 基本概念与基本使用
爱喝汤的技术少年
98 1
雨溪-yuxi
|
21天前
|
Web App开发 JavaScript 前端开发
2024年5月node.js安装(winmac系统)保姆级教程
本篇博客为2024年5月版Node.js安装教程，适用于Windows和Mac系统。作者是一名熟悉JavaScript与Vue的大一学生，分享了Node.js的基本介绍、下载链接及简单安装步骤。安装完成后，通过终端命令`node -v`验证版本即可确认安装成功。欢迎关注作者，获取更多技术文章。
雨溪-yuxi
23 2
2024年5月node.js安装(winmac系统)保姆级教程
芯在这
|
7月前
|
存储 算法 API
面向企业的区块链教程（一）（2）
面向企业的区块链教程（一）
芯在这
107 6
cqtianxin1
|
2月前
|
JavaScript 前端开发 Java
Node.js 教程
10月更文挑战第1天
cqtianxin1
48 0
你都不懂
|
4月前
|
JavaScript NoSQL 前端开发
Node.js 安装与使用及连接 MongoDB 的详细教程
【8月更文挑战第25天】
你都不懂
146 1
HermanYe996
|
4月前
|
机器人 Python
ROS2教程 03 节点Node
本文是关于ROS2（机器人操作系统2）的教程，介绍了ROS2的节点概念、与ROS1的区别、节点的编写和基本流程、ros2的node相关命令，以及如何对节点名进行重映射，旨在帮助读者理解ROS2中节点的创建和操作。
HermanYe996
124 0
ROS2教程 03 节点Node
路边两盏灯
|
4月前
|
负载均衡 微服务 Windows
【Azure微服务 Service Fabric 】使用az命令创建Service Fabric集群
【Azure微服务 Service Fabric 】使用az命令创建Service Fabric集群
路边两盏灯
22 0
朝阳39
|
5月前
|
开发框架 监控 JavaScript
企业级node.js开发框架 【egg.js】 实用教程
企业级node.js开发框架 【egg.js】 实用教程
朝阳39
71 0

热门文章

最新文章

  • 1
    关于区块链，你绝不能忽视的4个安全问题和5招应对方法！
  • 2
    曾鸣：区块链是否要“去中心化”？ | 阿里内部干货
  • 3
    当人工智能遇上区块链，会发生什么？
  • 4
    300行Kotlin代码实现的区块链
  • 5
    市场调研：2023年区块链市场规模有望突破160亿美元
  • 6
    区块链智能资产的“硬链接”思考
  • 7
    一边转载一边学习区块链
  • 8
    塞拉利昂利用区块链追踪选举结果，区块链史上首次参与到了政府选举中
  • 9
    微软携手美国银行发力区块链
  • 10
    蒋涛：我们还处在区块链的“Windows 2.0”时代，懂技术的人员太缺了
  • 1
    第十八章 Python批量管理主机(paramiko、fabric与pexpect)
    115
  • 2
    Canvas库 fabric.js可以实现哪些功能？ 动图介绍
    155
  • 3
    Python 的服务器管理：什么是服务器管理工具 Fabric？如何使用它进行远程命令执行和文件传输？
    114
  • 4
    Data Fabric：一站式数据管理与服务
    97920
  • 5
    DHorse改用fabric8的SDK与k8s集群交互
    100
  • 6
    Hyperledger fabric智能合约编写（一）
    177
  • 7
    Hyperledger Fabric相关概念介绍
    268
  • 8
    Hyperledger fabric部署链码（五）初始化与链码升级
    208
  • 9
    Hyperledger fabric部署链码（四）提交链码定义到channel
    98
  • 10
    Hyperledger fabric部署链码（三）批准链码定义
    137

    • 相关课程

    更多
  • Node.js 入门与实战
  • Node.js 入门教程文档

    • 相关电子书

    更多
  • 区块链和可问责服务
  • 区块链在当前实际金融业务应用中的关键技术实施和解决方案
  • IBM区块链之道

    • 相关实验场景

    更多
  • 前端开发基础6：Node.js和LESS预编译工具
  • 搭建Node.js编程环境
    • 下一篇
    阿里云对象存储OSS收费标准：存储、流量和请求等多个计费项详解