tp钱包官网|hyperledger fabric教程

作者： tp钱包官网

2024-03-17 04:20:25

hyperledger fabric教程资源 - 知乎

hyperledger fabric教程资源 - 知乎切换模式写文章登录/注册hyperledger fabric教程资源汇智网学习软件编程本文汇总整理超过100个超级账本Fabric开发与安装运维相关的教程与工具。推荐的系统化教程：Fabric Node.js开发详解 | Fabric Java开发详解 | Fabric Golang开发详解超级账本Fabric基本概念20个最重要的Hyperledger Fabric概念：本文介绍Hyperleger Fabric区块链的20个最重要的术语和概念，理解这些概念将极大地改善你的超级账本Fabric区块链的掌握和运用。区块链与分布式超级帐本技术：在本文中，我们将评估面向平台的主要企业的基本业务功能，包括以太网，Hyperledger Fabric和R3 Corda，无论是通过传统的分布式系统还是通过现代的区块链基础系统，都可以从软件获取其影响的位置以及系统的整体优化方式进行评估。Fabtoken - 超级账本Fabric 2.0的神秘宝石：Hyperledger Fabric 2.0 (alpha)中有一个新特性：Fabtoken，可以原生支持数字加密货币的发行与管理。我们都知道以太坊的ERC20标准可以用来在以太坊区块链上创建数字加密代币，现在有了Fabtoken，开发者使用 Hyperledger Fabric也可以轻松实现数字加密货币的发行、转账等功能了！手把手教你走进Hyperledger Fabric：现在，Blockchain是业内新的热门话题。但是，寻找良好的资源来学习这项引人入胜的技术并不是一件容易的事。为了让其他人更容易学习，我开始在区块链和分布式分类帐技术（DLT）平台领域开展一系列工作。我将尽力涵盖每一步都需要掌握这些技术。首先，我从Hyperledger Fabric开始。Hyperledger 框架和模块：通过这篇文章，你会明白：Hyperledger和免许可区块链技术之间的差异、Hyperledger的框架组件、Hyperledger框架（Iroha，Sawtooth，Fabric，Indy和Burrow）、Hyperledger模块（Cello, Explorer, and Composer）。你可以将Hyperledger视为市场，数据共享网络，微货币和去中心化数字社区的操作系统。Hyperledger Fabric一个企业级商业解决方案的平台：区块链将改变我们开展业务的方式。共享不可变的分类帐即超级账本和智能合约编码的组合将重新定义信任在企业中的表现方式。这个关于Hyperledger Fabric的博客将帮助你理解如何在区块链系统上按以下顺序建立业务网络...Fabric链码开发Fabric node.js链码API手册：fabric-contract-api提供了一个高度封装的开发接口，使用该API可以在高层级编写智能合约的业务逻辑。而fabric-shim则提供了底层的链码开发接口。超级账本Fabric 2.0外部链码实战：在Hyperledger Fabric 2.0中引入的一个新特性，就是可以使用外部的链码启动器，这种外部启动链码的方式非常适合使用kubenetes或dowcker swarm来统一管理节点容器和链码容器。在这片文章中，我们将学习如何使用外部链码启动器在K8s集群中部署链码。超级账本Fabric 2.0链码操作详解：Hyperledger Fabric 2.0最近已经发布，其中最引人关注的一点是链码操作。官方文档虽然对此提供了详细的说明，但本文将通过与 Hyperledger Fabric前一个版本中链码操作的对比，来帮助你更好的理解新版本中链码操作的不同之处以及幕后的一些技术细节。用链码实现Fabric链上数据加密/解密：Hyperledger Fabric是最流行的区块链开发框架之一，它有独特的定位和一些鲜明的特点，例如许可制架构、可插拔组件、支持私密交易的通道、模块化以及可扩展性，因此适合企业联盟链应用的开发。在这篇文章中，我们将介绍如何使用链码加密/解密保存在Hyperledger Fabric区块链上的敏感数据。超级账本Fabric链码开发的8条军规：我相信智能合约（链码）是Hyperledger Fabric区块链网络的核心。正确开发链码可以真正发挥一个安全区块链的优势，反之则会带来灾难性的后果。在这篇文章里我不打算探讨Hyperledger Fabric链码设计的特定模式的好与坏，而是希望分享我在开发若干Hyperledger Fabric概念验证应用过程中总结的一些基本准则。超级账本Fabric状态读写API简介：在这篇文章中，我们将学习链码读/写Hyperledger Fabric账本中世界状态的方法，这是利用PutState和GetState这两个API来实现的。此外，GetState还有一些变体的调用形式，使状态读取的方式更加灵活。通过Java Chaincode实例学习交易系统中基于Hyperledger Fabric帐户的钱包模型：这是Hyperledger Fabric Java Chaincode的教程。还有Go和NodeJS Chaincodes，我们将来可能会讨论它们。此外，我采用基于帐户的钱包模型作为示例，我们将使用Hyperledger Fabric构建你的第一个网络（BYFN，build your first network），作为我们的测试环境（v1.4网络）。ERC20 代币作为 Hyperledger Fabric Golang 链码:与以太坊区块链一样，Hyperledger Fabric平台（HLF）可用于创建代币，实现为智能合约（HLF术语中的链码），用于保存用户余额。与以太坊不同，HLF链码不能将用户地址用作持有者密钥，因此我们将使用成员资格服务提供程序（MSP）标识符和用户证书标识符的组合。下面是一个简单的示例，说明如何使用CCKit链码库在Hyperledger Fabric平台上创建代币作为Golang链码。Fabric Node.js链码开发秒懂：Hyperledger Fabric是一种联盟区块链，Fabric区块链也支持智能合约，被称为链码（Chaincode）。Fabric链码就是一个标准的（运行在docker容器中的）操作系统进程，通过gRPC协议与Fabric节点通信。因此理论上可以使用任何语言开发Fabric链码。目前官方提供了三种开发语言的Fabric链码开发工具包：Go、Java和Node.js，本文将介绍如何使用node.js开发Fabric链码。用.NET/C#开发Fabric链码：本教程介绍如何使用.NET Core开发一个简单的Hyperledger Fabric 链码，用于进行基本的资产管理和转账操作。如果你是一个熟练的.NET/C#开发人员，由于种种原因需要使用Hyperledger Fabric作为区块链平台，那么除了转身投入Java/Node.js/Go的怀抱之外，这也提供了另外一种选择。如何编写Golang链码并调用链码函数：Chaincode是我们定义应用程序逻辑（函数）的地方。Chaincode需要安装在将与Hyperledger fabric交互的每个节点上。它还需要在通道上实例化。之后，最终用户可以通过与网络节点连接的客户端应用程序调用链代码功能。Chaincode是用Go，node.js或Java编写的程序，它实现了指定的接口。Fabric应用开发fabric区块链Go语言SDK快速入门：fabric-sdk-go是Hyperledger Fabric官方提供的Go语言开发包，应用程序可以利用fabric-sdk-go与fabric网络进行交互并访问链码。本教程介绍如何使用fabric-sdk-go实现链码的安装、实例化、交易提交和状态查询等操作。Farbic Java SDK 1.4安装方法：Hyperledger Fabric Java SDK是开发基于Hyperledger Fabric区块链的Java 应用之必备开发包。本文将介绍如何在Maven、Gradle和Eclipse中安装使用Hyperledger Fabric Java SDK。Fabric java sdk 1.4简明教程：在超级账本Fabric区块链中，应用通过节点的RPC协议接口访问链码。Java应用可以使用官方提供的Fabric-sdk-java开发包来实现对链码的访问，开发包封装了Fabric 区块链的GRPC链码访问协议，有利于开发人员聚焦于业务逻辑。不过Fabric-sdk-java的文档质量保持了Hyperledger Fabric产品一贯的不知所云，看起来实在是令人捉急。本文将尝试编写一个最简单的可以访问Fabric链码的Java应用，来帮助你快速上手Farbic区块链的Java应用开发。使用Hyperledger Fabric Java SDK 构建和部署区块链网络：学习如何使用Hyperledger Fabric SDK Java创建，部署和测试区块链网络。此模式将提供由两个组织组成的Hyperledger Fabric 1.1网络，每个组织维护两个对等节点，每个组织有两个证书颁发机构（ca）和一个单独订购服务。Fabric node sdk 1.4简明教程：hyperledger fabric的node sdk最新版本为1.4，本文将介绍如何使用最新版本的fabric node sdk开发node.js应用，以实现与fabric区块链的交互，例如查询链码状态，或者提交链码交易。本文分五个部分来介绍node.js开发人员如何快速上手fabric node sdk。Fabric Node.js开发中如何使用日志：Hyperledger Fabric Node.js开发中如何使用日志？本教程就来演示下如何使用hyperledgefabric node.js客户端日志记录功能。fabric-sdk-node应用中使用CouchDB钱包：当应用与Hyperledger Fabric网络交互时，Fabric节点会首先验证应用的身份，也就是应用所持有的证书是否允许访问Hyperledger Fabric 网络。在Hyperledger中，这些身份信息保存在钱包中。在这个教程中我们将介绍如何在应用中使用CouchDB钱包来保存证书和私钥资料。超级账本Fabric Node.js应用中如何使用基于通道的事件服务：本教程说明了基于通道的事件的使用。这些事件与现有事件类似，但是特定于单个通道。在设置侦听器时，客户端处理基于通道的事件有一些新选项。从v1.1开始，基于通道的事件是Hyperledger Fabric Node.js客户端的新功能。Hyperledger Fabric PHP SDK：Hyperledger Fabric PHP SDK是社区提供的用于Hyperledger Fabric区块链应用开发的软件包，其目的在于为PHP应用提供访问Hyperledger Farbic区块链的能力，例如：创建通道、安装链码、访问链码等等。如何监听Fabric链码的事件：在本文中，我们将讨论Fabric链码中不同类型的基于通道的事件和事件监听器，何时使用它们，特别是我们将学习如何实现Fabric chaincode事件监听器。本文简化并详细解释了有关Fabric主题的官方教程的版本，因此我们建议你也阅读。超级账本Fabric如何查询历史交易在以太坊、比特币等区块链平台中，通常都会提供简单的JSON RPC API接口，应用程序只需要调用这些RPC API，就可以查询区块或历史交易了。Hyperledger Fabric 也有类似的API，但情况略有不同，根据查询目的区别，可以分为两种方法。超级账本Fabric Rest API服务开发教程与代码：Hyperledger Fabric 提供了软件开发包/SDK以帮助开发者访问fabric网络和部署在网络上的链码，但是Hyperledger Fabric官方没有提供简单易用的REST API访问接口，在这个教程里我们将学习如何利用Hyperledger Fabric的SDK 来开发REST API服务器。如何编写一个企业级Hyperledger Fabric开源框架：Convector（a.k.a Convector Smart Contracts）是为企业区块链框架构建的JavaScript开发框架。它增强了开发体验，同时帮助开发人员创建更强大，更安全的智能合约系统。它通过链代码和后端一直到前端，允许开发人员以库的形式重用相同的代码库。它基于模型/控制器模式，支持Hyperledger Fabric，并沿着Fabric精心设计的模式本地运行。使用Hyperledger Fabric和Composer实现区块链应用程序：目前无法绕过技术领域的是区块链话题。但除了加密货币之外，还有更多有趣的应用程序可以带来许多激动人心的软件生态系统。这也适用于Hyperledger项目，该项目提供了一个非常模块化的区块链框架。让我们看看使用Hyperledger Fabric和Composer实现区块链应用程序是多么容易Fabric共识算法与排序服务深入理解超级账本Fabric交易背书机制：Hyperledger Fabric和其他许多区块链的关键区别之一，就在于 Fabric区块链的交易执行过程：Fabric交易需要首先通过节点的背书，然后再进行交易排序，最后才利用有序交易进行账本的更新。本文将介绍Hyperledger Fabric所采用的执行-排序-验证这一三步交易模型的工作原理，以及引入背书环节对Hyperledger Fabric区块链性能的有益作用。超级账本Fabric Raft排序服务多机部署实践：Raft是Hyperledger Fabric 1.4.1中新增的排序服务模块，这个教程将介绍如何部署一个基于Raft排序服务的多机Fabric 网络。Fabric区块链Raft共识深度解析与实战：Raft共识插件是在Hyperledger Fabric 1.4.1后引入的，与之前已有的Solo共识和Kafka共识相比，Raft共识更适合生产环境。本文将介绍共识的基本概念、Raft共识的原理并深入探讨基于Raft共识的 Hyperledger Fabric排序服务。Fabric区块链Kafka入门：Hyperledger Fabric推荐Kafa用于生产环境。Kafa是一个分布式、具有水平伸缩能力、崩溃容错能力的日志系统。在Hyperledger Fabric区块链中可以有多个Kafka节点，使用zookeeper进行同步管理。本文将介绍Kfaka的基本工作原理，以及在Hyperledger Fabric中使用Kafka和zookeeper实现共识的原理，并通过一个实例剖析Hyperledger Farbic中Kafka共识的达成过程。Fabric身份认证与数据隐私Fabric CA使用手册：Fabric CA服务器和客户端官方文档中文版超级账本Fabric中的身份机制原理与实践：身份是许可区块链平台的一个重要特征。在Hyperledger Fabric中，需要在访问结构网络之前识别每个组件。身份Identity由X.509数字证书表示。当与结构网络交互时，该actor指定并呈现数字证书，并且结构网络基于该策略接受或拒绝。在本文中，我们首先运行基本网络并在其上部署Simple Asset Chaincode。通过检查容器设置和链代码操作，我们将看到在链代码调用期间如何呈现身份。最后，我们引入客户端身份链代码库来捕获用户的身份并基于主题执行访问控制。在超级账本Fabric区块链应用中使用第三方CA：Hyperledger Fabric（HF）为终端用户使用自有CA提供了fabric-ca 工具。然而在生产环境中应当尽可能保证根CA的安全性，例如让根CA离线，而将Hyperledger Fabric环境中的证书签发代理给中间 CA。在本文中，我们将介绍如何使用第三方CA作为根CA，使用fabric-ca 作为中间CA，以及如何在CA信任链中整合第三方CA与fabric-ca。超级账本 Fabric双向TLS配置与连接方法：Hyperleder Fabric区块链支持在通信节点之间启用TLS传输层安全通信， TLS支持单向验证 - 仅验证服务节点身份，或双向验证 - 同时验证服务节点和客户端节点的身份。本文将介绍如何在Hyperledger Fabric 网络中启用双向TLS安全通信。超级账本Fabric CA教程：Fabric-CA是Hyperledger Fabric自带的证书管理工具，对于开发和测试非常方便。在这个教程中我们将探索Fabric-CA的使用方法并利用它完成用户的注册/Register和登记/Enrollment。Fabric private data基本概念：fabric private data利用SideDB来保存私有数据，相当于在通道之上又提供了一层更细粒度的数据隐私保护机制。本文将介绍fabric private data 的引入目的、基本概念与应用场景。超级账本Fabric私有数据与暂态数据：在Hyperledger Fabric中有两个相关的概念：私有数据（Private Data）和暂态数据（Transient Data）。本文提供四个示例程序，分别对应私有数据和暂态数据的四种组合使用方式，并通过观察账本的交易以及世界状态数据库，理解为什么在使用私有数据时应当采用暂态数据作为输入。Fabric private data入门实战：Hyperledger Fabric private data是1.2版本引入的新特性，fabric private data是利用旁支数据库（SideDB）来保存若干个通道成员之间的私有数据，从而在通道之上又提供了一层更灵活的数据保护机制。本文将介绍如何在链码开发中使用fabric private data。Hyperledger Composer Rest服务器的Passport-JWT身份验证：我们最近介绍了Hyperledger Composer入门，在本文中，我们将执行以下操作：创建示例业务网络定义、使用Docker和PassportJWT身份验证生成Composer Rest服务器、使用自定义JWT令牌使用Authenticated API。Fabric区块链比选与兼容以太坊和Hyperledger Fabric之间的差异：在这篇文章中，我们将介绍区块链中两个主要平台之间的差异：以太坊和Hyperledger。如果你正在考虑在项目中使用哪一个。这个博客的亮点是希望帮助你做出决定。但在我们详细说明之前，我们先来看一些定义。用Solidity智能合约实现超级账本Fabric与ARK公链跨链：我想展示如何将公共区块链（如http://ARK.io）的功能与私有区块链（如Hyperledger）结合起来。特别是，我们将看到http://ARK.io上的交易如何触发在Hyperledger Fabric + Burrow中部署的Solidity Smart Contract的执行。Hyperledger Fabric可以支持以太坊：本着扩展选择的精神，Hyperledger Fabric现在支持以太坊虚拟机（EVM）字节码智能合约。合约现在可以用Solidity或Vyper等语言编写。除了引入新的智能合约运行时，Fabric还有一个相应的web3提供程序，可用于使用web3.js开发去中心化的应用程序（DApps）。这一新功能是1.3版本的一部分，其目标是使开发人员能够为许可平台迁移或创建DApp。超级账本Fabric如何通过虚拟机部署以太坊智能合约：EVM作为用户链代码安装到Fabric中，然后可以通过它部署智能合约。单个EVM链代码足以在通道上运行多个以太坊智能合约。链码不采用以太坊的共识方法。所有事务仍将遵循Fabric事务流中的执行，订单，验证步骤。确保在不同组织中的足够对等方安装链代码，并设置一个确保一定程度的分散的认可政策。为了与已部署的智能合约进行交互，有一个fab3，它从以太坊JSON RPC API实现一组有限的API，因此可以用作web3提供者。Fabric性能基准测试超级账本Caliper测试框架文档：Hyperledger Caliper是一个通用的区块链性能测试框架，它允许用户使用自定义的用例测试不同的区块链解决方案，并得到一组性能测试结果。中文文档由汇智网翻译整理。超级账本Caliper多排序节点基准测试：在这个教程中，我们将学习如何使用Hyperledger Caliper对包含多个排序节点的Fabric网络进行基准测试，我们使用Docker Swarm 作为容器编排工具。Hyperledger Fabric能否大规模运行：在我主持的IBM博客上，我发起了一系列帖子，旨在提供有关Hyperledger Fabric的性能和规模的信息。我关于这个主题的最初博客文章开始概述了一些改进Hyperledger Fabric性能的最佳实践，这些实践是我从Fabric认可策略，负载平衡和orderer配置的实验中收集到的。我最近的帖子解决了Fabric对扩展其通道架构能力的一种常见误解。Fabric网络运维超级账本Fabric命令手册：Hyperledger Fabric区块链的部署与运维依赖于几个重要的命令行工具：peer、configtxgen、configtxlator、cryptogen、fabric-ca。Fabric命令环境变量手册：Fabric命令行程序以来的环境变量说明。configtx.yaml中文详解：configtx.yaml是Hyperledger Fabric区块链网络运维工具configtxgen用于生成通道创世块或通道交易的配置文件，configtx.yaml的内容直接决定了所生成的创世区块的内容。本文将给出configtx.yaml的详细中文说明。超级账本区块链浏览器官方文档中文版：超级账本官方提供的区块链浏览器是一个简单易用的开源工具，可以用于监视区块链网络中的活动。Hyperledger Explorer支持Fabric、Iroha等多种区块链，可以运行在MocOS和Ubuntu下。超级账本区块链浏览器中文版快速安装教程：超级账本区块链浏览器的官方安装步骤有点复杂，建议参考这个快速安装教程，同样适用于英文原版。超级账本Fabric的运维服务与可视化监控：Hyperledger Fabric是强调运维的区块链，Fabric自1.4版本开始就包含了用于peer和orderer节点运维的特性。本教程将介绍如何配置Fabric网络节点的运维管理服务，以及如何使用Prometheus和statsD/Graphite来可视化监控 Hyperledger Fabric网络中各节点的实时运行指标。Fabric网络安装部署Fabric BYFN网络一键安装工具：Byfn.win 是Hyperledger Fabric著名的byfn.sh脚本的Windows 版本的移植，用于帮助开发人员在Windows环境中快速搭建Hyperledger Fabric链码及应用开发环境。官方下载地址。超级账本Fabric 2.0 安装教程：本文介绍如何安装最新的Hyperledger Fabric 2.0的预编译程序、 fabric-samples示例配置和代码以及docker镜像。超级账本Fabric 1.4 多通道实验：Hyperledger Fabric支持在一组相同的机构之间的多通道部署，每个通道都相当于一个单独的区块链。Fabric的多通道特性不仅可以满足机构之间不同的数据共享需求，同时也可以提高整个Fabric网络的吞吐量。本文将演示如何使用Hyperledger Fabric 1.4.3搭建一个多通道的区块链网络、部署并访问链码。超级账本Fabric多机部署教程：Hyperledger Fabric区块链网络搭建以繁琐著称。本教程将介绍如何部署一个分布在4个主机上包含多个排序节点和对等节点的 hyperledger fabric区块链集群网络，同时提供源码和配置文件下载。如何设置Hyperledger Fabric主机并构建机器镜像这里我以AWS为例。通过构建我自己的亚马逊机器镜像（AMI），我可以轻松启动包含我需要的所有组件的EC2实例。我们的主机将运行Ubuntu18.04，包含必备和Hyperledger Fabric相关工具和镜像。安装好所有东西后，我会把它变成AMI。最后，我们将展示如何使用此AMI启动新主机。最后一步正是我们下次需要新的Hyperledger Fabric主机时需要做的事情。如何使用Hyperledger Fabric和Composer构建区块链网络:如何使用Hyperledger Fabric和Composer构建区块链网络，这是一个区块链开发入门人员的教程。在开始之前要说明Hyperledger Fabric仅在基于Unix的操作系统上运行。因此，它将无法在Windows上运行，这将对你可以执行的操作进行限制。如果你在继续操作之前运行Windows，我建议你设置虚拟机。多个主机上的Hyperledger Fabric：没有教程或指南可以帮助你跨多个主机部署网络。许多人在同一问题上围绕不同的论坛挣扎。我决定首先研究现有的样本，以了解超级分类网络的不同组件如何能够在单个主机上进行通信。在一台Ubuntu计算机上构建Hyperledger Fabric网络：在本教程中，我们将演示如何使用Cello将具有所有必要组件的小型Hyperledger Fabric（版本1.0.2）网络部署到单个Ubuntu服务器，以便你可以开始开发基于区块链的应用程序。Hyperledger Fabric中三节点双通道设置的演示（一） / （二）：从λ.eranga有一种更简单的方法。通过使用额外的主机。这使得运行容器之间的通信更容易，只要我们在启动网络时提供必要的信息。受这项工作的启发，我在这里部署了一个在三台独立机器上运行的三组织结构网络。更有趣的是我将在此设置上部署两个频道，并了解事情是如何运作的。超级账本Fabric的容灾备份及恢复方法简介：Hyperledger Fabric日益增强的潜力使得许多企业正在尝试使用fabric。当使用涉及更多peers和orderers的大型网络时，维护超级账本数据的备份非常重要。如果网络出现故障，这将有所帮助。它还有助于开发阶段，因为可以使用备份数据来执行将来的测试。在本文中，我将介绍如何进行备份以及如何在Hyperledger Fabric中使用备份。如何创建 Hyperledger Fabric 通道：本教程演示如何使用node.js fabric client sdk创建Hyperledger fabric 通道，也有的人叫频道。它演示了如何使用初始化（默认）通道定义以及如何从该定义开始构建自定义的通道定义。创建网络和通道的过程还涉及创建和使用加密资料，这里不讨论这一点。如何在现有Fabric网络上添加一个Org ：如何在现有Fabric网络上添加一个Org？本指南基于IBM DeveloperWorks——使用简单的工具将组织添加到现有的Hyperledger Fabric区块链网络中。---原文链接：Hyperledger Fabric教程大全 — 汇智网发布于 2020-03-20 10:59Hyperledger教程赞同 551 条评论分享喜欢收藏申请

万字解析——区块链hyperledger fabric2.2部署实战教程_hyperledger fabric教程-CSDN博客

万字解析——区块链hyperledger fabric2.2部署实战教程

做毕设的大企鹅

已于 2022-11-16 15:10:35 修改

阅读量2.1w

234

点赞数

分类专栏：

区块链

文章标签：

区块链

fabric

于 2022-05-25 14:51:48 首次发布

本文链接：https://blog.csdn.net/weixin_44165950/article/details/124857431

版权

区块链

专栏收录该内容

3 篇文章

17 订阅

订阅专栏

导航

一、前言二、hyperledger fabric介绍三、测试网络示例3.1 搭建开发环境3.2 安装示例、二进制和 Docker 镜像3.3 使用Fabric测试网络3.4 使用认证机构建立网络

四、汽车生产应用4.1 搭建开发环境4.2 注册登记等操作使用4.3 智能合约4.4 更新账本

五、商业票据应用5.1 运行网络5.2 以MagnetoCorp身份管理员身份开发人员身份

5.3 以 DigiBank 的身份5.4 应用结构5.5 钱包5.6 发行应用5.7 DigiBank应用

附加问题结语

一、前言

本教程在ubuntu20版本下运行，请在执行操作前先部署ubuntu20环境，所有部署都按照官方文档hyperledger fabric进行，在运行过程中遇到的问题，我也会逐个说明，如果你对于区块链还不太了解，请先查阅区块链概念，文中若有理解不对的地方，欢迎批评指正。

二、hyperledger fabric介绍

Hyperledger Fabric 是 Hyperledger （超级账本）中的区块链项目之一，也是经典的联盟链之一。它有一个账本，使用智能合约，由参与者管理交易的系统，但它又不完全去中心化，即想要加入联盟的成员们需要从可信赖的成员服务提供者（MSP）注册，以下是一些相关概念的介绍。

名词解释资产记录的数据，通常为json格式表示键值对的集合链码业务逻辑，即智能合约，定义修改交易指令资产记录的数据，通常为json格式表示键值对的集合账本特性基于键、范围和组合查询等特性隐私创建的通道之间是相互分隔的，虽然允许组织间共享网络基础设施，但也可以被私有化安全和成员服务所有成员公开，可以在更广泛的网络和通道上操作管理数据共识从提案和背书到排序、验证和提交，都有共识验证在里面，以保证交易达成共识，防止双花区块链网络为应用程序账本及智能合约（链码）服务的技术基础设施

下图为Fabric的结构：下图为Hyperledger Fabric 的结构,详解见区块链网络：

三、测试网络示例

3.1 搭建开发环境

1.安装git

sudo apt-get install git

2.安装curl

sudo apt-get install curl

3.安装docker

# 安装并检查版本

sudo apt-get -y install docker-compose

docker --version

docker-compose --version

# 提示，以后只要碰到docker有关的错误，先执行2.3.1步骤

#1.重启docker

sudo systemctl start docker

#设置系统启动时docker启动，可选

sudo systemctl enable docker

#2.将用户添加到docker组，确保在用户命令下可以执行

sudo gpasswd -a $USER docker

#3.更新用户组

newgrp docker

# docker信息

docker info

# 测试docker，若报错详见文末附加问题1

docker run hello-world

4.安装go

安装并解压：

mkdir ~/download

cd ~/download

# 下载

wget https://studygolang.com/dl/golang/go1.13.linux-amd64.tar.gz

# 解压

sudo tar -C /usr/local -xzf go1.13.linux-amd64.tar.gz

创建go目录并配置环境：

mkdir $HOME/go

#用vi打开~./bashrc，配置环境变量

vi ~/.bashrc

# 在最下方插入

export GOROOT=/usr/local/go

export GOPATH=$HOME/go

export PATH=$PATH:$GOROOT/bin:$GOPATH/bin

#使配置的环境变量生效

source ~/.bashrc

#检查是否配置正确

go version

# 配置goproxy环境变量加速国内下载

go env -w GOPROXY=https://goproxy.io

3.2 安装示例、二进制和 Docker 镜像

1.克隆 hyperledger/fabric-samples 仓库

mkdir -p $GOPATH/src/github.com/hyperledger

cd $GOPATH/src/github.com/hyperledger

# 获取fabric-samples源码

git clone https://github.com/hyperledger/fabric-samples.git

2.选择适当的版本标签，进入目录，切换分支

cd fabric-samples

# 可自行选择版本

git checkout release-2.2

#查看版本

git branch

3.将指定版本的 Hyperledger Fabric 平台特定二进制文件和配置文件安装到 fabric-samples 下的 /bin和 /config 目录中，下载指定版本的 Hyperledger Fabric docker 镜像先配置镜像源：

sudo vi /etc/docker/daemon.json

#把以下代码加进去

{

"registry-mirrors":["https://registry.docker-cn.com"]

}

#如果你想要最新的生产发布版本，忽略所有的版本标识符。

# curl -sSL https://bit.ly/2ysbOFE | bash -s

# curl -sSL https://bit.ly/2ysbOFE | bash -s --

# 若报错详见文末附加问题2

curl -sSL https://bit.ly/2ysbOFE | bash -s -- 2.2.0 1.4.7 0.4.18

# 若不行试试下面这个

curl -sSL https://raw.githubusercontent.com/hyperledger/fabric/master/scripts/bootstrap.sh | bash -s 2.2.0 1.4.7 0.4.18

多试几次会成功的！我们可以看到全部下载完毕了

cd chaincode-go

sudo vi go.mod

# 进入文件发现是1.14 自己把改成1.13 ，要与你下载的go版本匹配

环境变量设置

vi ~/.bashrc

# 添加下面的变量

export PATH=$PATH:$GOPATH/src/github.com/hyperledger/fabric-samples/bin

# 使之生效

source ~/.bashrc

# 检验成功否

fabric-ca-client version

3.3 使用Fabric测试网络

温馨提示：在你看到这里的时候，说明你的环境已经部署完毕，接下来要使用测试网络，需要注意的是一定要在一个完整的时间段操作，不要断断续续地执行下述操作，否则可能会出现大堆新手难解决的问题！

比较重要的一点，遇到问题时开启debug模式！开启debug模式！开启debug模式！

export FABRIC_LOGGING_SPEC=debug

1.启动测试网络进入fabric-samples下的test-network 先来分析一下network.sh脚本

# 脚本有500多行，在这讲解脚本里的一些方法

function clearContainers()# 清除容器

function removeUnwantedImages() # 清除不想要的镜像

# 大家仔细看看都能读懂，下面挑几个关键且常用的讲

#创建组织

function createOrgs() {

# 这里包含一些业务逻辑比如

# Create crypto material using cryptogen or Fabric CA

if [ "$CRYPTO" == "cryptogen" ];then...

if [ "$CRYPTO" == "Certificate Authorities" ]; then..

}

# 创建联盟

function createConsortium()

# 开启网络

function networkUp()

# 创建channel

function createChannel()

# 开启链码

function deployCC()

# 最后给出了一些确定操作模式并打印出我们所要求的内容

if [ "$MODE" == "up" ]; then

infoln "Starting nodes with CLI timeout of '${MAX_RETRY}' tries and CLI delay of '${CLI_DELAY}' seconds and using database '${DATABASE}' ${CRYPTO_MODE}"

elif [ "$MODE" == "createChannel" ]; then

infoln "Creating channel '${CHANNEL_NAME}'."

infoln "If network is not up, starting nodes with CLI timeout of '${MAX_RETRY}' tries and CLI delay of '${CLI_DELAY}' seconds and using database '${DATABASE} ${CRYPTO_MODE}"

elif [ "$MODE" == "down" ]; then

infoln "Stopping network"

elif [ "$MODE" == "restart" ]; then

infoln "Restarting network"

elif [ "$MODE" == "deployCC" ]; then

infoln "deploying chaincode on channel '${CHANNEL_NAME}'"

else

printHelp

exit 1

if [ "${MODE}" == "up" ]; then

networkUp

elif [ "${MODE}" == "createChannel" ]; then

createChannel

elif [ "${MODE}" == "deployCC" ]; then

deployCC

elif [ "${MODE}" == "down" ]; then

networkDown

else

printHelp

exit 1

执行以下命令以执行脚本network.sh

./network.sh up

执行完毕后看到，我们创建了排序组织orderer、联盟成员org1的peer0节点和联盟成员org2的peer0节点以及相应的镜像image。 2.测试网络的组成部分执行docker ps -a 可以看到创建的三个节点和之前测试的hello-world Fabric网络成员的所有组织称为联盟，此测试网络有两个联盟成员org1、2，一个维护网络排序服务的组织orderer，每个组织各运营一个对等节点，peer0.org1.example.com和peer0.org2.example.com。 peer节点是fabric网络的基本组件，最常见的peer节点就是背书节点，对等节点存储区块链账本进行交易之前的验证。该示例网络使用单节点Raft排序服务，以前的版本有solo模式和kafka模式，此测试仅使用单节点排序服务，但一个真实的网络将有多个排序节点，由一个或多个排序者组织。

3.创建一个channel

使用./network.sh createChannel 在org1和org2之间创建通道并加入他们的对等节点，如下有几种方法：

# 1.不输入自定义名称通道，默认为mychannel

./network.sh createChannel

# 2.输入自定义名称，可以创建多个不同名称通道

./network.sh createChannel -c channel1

./network.sh createChannel -c channel2

# 3.也可以建立网络创建通道一起

./network.sh up createChannel

4.在通道启动一个链码在fabric 中，链码就是指的智能合约。在创建通道后，开始部署链码与通道账本交互，链码包含区块链账本上资产的业务逻辑，用的go语言编写，后面会详细介绍。由成员运行的应用程序网络可以在账本上调用只能合约创建，更改和转让资产。为确保交易有效，使用智能合约创建的交易需要多个组织签名才能提交到账本，也就是背书，而智能合约也定义了背书策略，比如需要成员2/3同意便通过，一半成员同意通过等等。创建完通道，现在开始启动链码：

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

# 出错详见附加问题3

如下图就是链码启动成功了 5.与网络交互把fabric-samples的bin文件下的二进制文件添加到CLI路径：

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

还需要将fabric-samples代码库中的FABRIC_CFG_PATH设置为指向其中的core.yaml文件：

export FABRIC_CFG_PATH=$PWD/../config/

设置环境变量，允许用户作为org1操作peer的CLI：

# Environment variables for Org1

export CORE_PEER_TLS_ENABLED=true

export CORE_PEER_LOCALMSPID="Org1MSP"

#CORE_PEER_TLS_ROOTCERT_FILE和CORE_PEER_MSPCONFIGPATH环境变量指向Org1的organizations文件夹中的的加密材料。

export CORE_PEER_TLS_ROOTCERT_FILE=${PWD}/organizations/peerOrganizations/org1.example.com/peers/peer0.org1.example.com/tls/ca.crt

export CORE_PEER_MSPCONFIGPATH=${PWD}/organizations/peerOrganizations/org1.example.com/users/Admin@org1.example.com/msp

export CORE_PEER_ADDRESS=localhost:7051

接下来可以调用链码（Go）的 InitLedger 方法来赋予一些账本上的初始资产，运行如下命令，用一些资产来初始化账本：

peer chaincode invoke -o localhost:7050 --ordererTLSHostnameOverride orderer.example.com --tls --cafile ${PWD}/organizations/ordererOrganizations/example.com/orderers/orderer.example.com/msp/tlscacerts/tlsca.example.com-cert.pem -C mychannel -n basic --peerAddresses localhost:7051 --tlsRootCertFiles ${PWD}/organizations/peerOrganizations/org1.example.com/peers/peer0.org1.example.com/tls/ca.crt --peerAddresses localhost:9051 --tlsRootCertFiles ${PWD}/organizations/peerOrganizations/org2.example.com/peers/peer0.org2.example.com/tls/ca.crt -c '{"function":"InitLedger","Args":[]}'

如图，初始化成功！接下来可以用CLI工具查询账本：

peer chaincode query -C mychannel -n basic -c '{"Args":["GetAllAssets"]}'

还可以转账或改变资产所有者（也就是数据库中的改操作）：

执行完后，我们再查询一下，发现ID为asset6的拥有者已经变成了Christopher，如图：接下来我们可以通过org2的peer来查询，在这之前我们先设置一下org2的环境变量：

# Environment variables for Org2

export CORE_PEER_TLS_ENABLED=true

export CORE_PEER_LOCALMSPID="Org2MSP"

export CORE_PEER_TLS_ROOTCERT_FILE=${PWD}/organizations/peerOrganizations/org2.example.com/peers/peer0.org2.example.com/tls/ca.crt

export CORE_PEER_MSPCONFIGPATH=${PWD}/organizations/peerOrganizations/org2.example.com/users/Admin@org2.example.com/msp

export CORE_PEER_ADDRESS=localhost:9051

再查询一下

peer chaincode query -C mychannel -n basic -c '{"Args":["ReadAsset","asset6"]}'

结果和org1一样asset6转给了名叫Christopher的人至此测试完毕，我们关闭网络./network.sh down

3.4 使用认证机构建立网络

Hyperledger Fabric使用公钥基础设施(PKI)来验证所有网络参与者的行为。每个节点，网络管理员和用户提交的交易需要具有公共证书和私钥以验证其身份。这些身份必须具有有效的信任根源，该证书是由作为网络中的成员组织颁发的。在测试网络中，network.sh在创建节点之前就使用cryptogen工具创建了这些加密材料，现在让我们试试：

./network.sh up -ca

可以看到脚本启动了三个CA，分别是orderer、org1和org2。感兴趣的朋友在启动后查看一下脚本都做了些什么，在这里不做赘述。下面我们还可以查看一下org1的MSP文件夹，其中包含了每个身份的证书和私钥：

tree organizations/peerOrganizations/org1.example.com/users/Admin@org1.example.com/

# 如果没有tree请按照提示安装

#关闭网络

./network.sh down

四、汽车生产应用

4.1 搭建开发环境

安装python2.7，make，gcc，npm，开启远程服务以查看文档

sudo apt-get install python2.7

sudo apt-get install make

sudo apt-get install gcc

sudo apt install npm

# 安装

sudo apt-get install openssh-server

# 查看，存在sshd说明已启动

sudo ps -e |grep ssh

# 启动

sudo service ssh start

进入fabric-samples仓库下的fabcar，通过javasript版本的脚本来启动智能合约：

cd fabric-samples/fabcar

./startFabric.sh javascript

# 启动若报错，查看附加问题4

启动成功如图

4.2 注册登记等操作使用

本教程用 javascript 为nodejs编写的示例，先进入javascript文件夹：

cd javascript

该目录包含使用Node.js对应的Fabric SDK 开发的示例程序。运行以下命令安装应用程序依赖项：

npm install

完成后通过命令ls看一眼示例javaScript的应用文件：在我们创建网络时，证书授权服务器（CA）将创建一个管理员用户（admin），第一步使用enroll.js生成私钥、公钥和x.509证书：

node enrollAdmin.js

创建完之后，CA管理员的证书保存在wallet目录，可以再admin.id找到证书和私钥。接下来再创建一个新的应用程序用户，它将被用于与区块链交互。运行以下命令注册和记录一个名为 appUser 的新用户：

node registerUser.js

接下来我们来查询账本，最常用的查询是查询账本当前值（世界状态），我们先使用query.js来看看:

node query.js

如图为输出结果，我们可以看到查询数据为键值对，也就是json格式，当然我们也可以通过配置使用数据库（如CouchDB）来使用富查询。感兴趣的朋友可以把query.js分析一下，里头都是一些定义很容易看懂。

4.3 智能合约

导航到 fabric-samples 仓库里 JavaScript版本的FabCar智能合约：

cd fabric-samples/chaincode/fabcar/javascript/lib

打开fabcar.js，里面描述了智能合约如何使用 Contract 类定义的现在我们更改一下query.js的查询范围代码：

const result = await contract.evaluateTransaction('queryAllCars');

#改为

const result = await contract.evaluateTransaction('queryCar', 'CAR4');

这样保存后返回到fabcar/javascrip再执行：

node query.js

我们可以看到查询结构只变成了查询这一个车的数据

Wallet path: ...fabric-samples/fabcar/javascript/wallet

Transaction has been evaluated, result is:

{"color":"black","docType":"car","make":"Tesla","model":"S","owner":"Adriana"}

4.4 更新账本

刚才我们已经完成了一些账本的查询并添加修改查询，现在我们来更新账本（也就是数据库中的“增”）我们打开invoke.js 好了，现在我们知道原理后开始执行

node invoke.js

执行完毕后把query.js修改为之前的查询世界状态的代码，再查看

node query.js

如图，我们可以看到CAR12已经被添加进了交易功能，把车主把车卖了：

# 这就是invoke.js中的submitTransaction功能，

# 把方法由createCar修改为changeCarOwner

await contract.submitTransaction('changeCarOwner', 'CAR12', 'Dave');

再查询一下node query.js，就可以看到车主已经变成"Dave"了。至此，结束，返回到fabcar目录，清除数据，关闭测试网络：

./networkDown.sh

五、商业票据应用

本应用包含MagnetoCorp和DigiBank两个组织，它们使用区块链网络PaperNet相互交易商业票据，如图：流程是这样的：我是MagnetoCorp 的员工 Isabella，她将代表公司发行商业票据，然后转换角色，担任 DigiBank 的员工 Balaji，他将购买此商业票据，持有一段时间，再向 MagnetoCorp 赎回该商业票据，以获取小额利润。

5.1 运行网络

进入到fabric-samples中的commercial-paper目录，然后启动网络:

cd fabric-samples/commercial-paper

./network-starter.sh

注意这里的测试网络名称为fabric_test，官方教程写的net_test，注意下通过docker ps命令查看Fabric节点在本地机器上的运行情况：还可以通过docker network inspect fabric_test命令查看：

peer0.org1.example.com将属于DigiBank组织 peer0.org2.example.com将属于MagnetoCorp组织启动的网络称为PaperNet 启动后将有八个容器产生，对应八个不同的IP地址，可以通过docker network inspect net_test命令查看： 1.Org1的peer——peer0.org1.example.com 2.Org2的peer——peer0.org2.example.com 3.Org1的peer对应的CouchDB数据库——couchdb0 4.Org2的peer对应的CouchDB数据库——couchdb1 5.排序服务节点——orderer.example.com 6.Org1的CA——ca_org1 7.Org2的CA——ca_org2 8.排序服务Org的CA——ca_orderer

5.2 以MagnetoCorp身份

管理员身份

先切换到MagnetoCorp目录：

cd commercial-paper/organization/magnetocorp

在MagnetoCorp目录下，运行下列命令以运行monitordocker.sh脚本，并为运行在fabric_test上的与PaperNet相关联的容器启动logspout工具:

# 如果是非最高权限用户，请在下列命令前加上sudo

./configuration/cli/monitordocker.sh fabric_test

#如果 monitordocker.sh 中的默认端口已经在使用，可以传入一个端口号

#./monitordocker.sh net_test

./monitordocker.sh net_test 8079

开发人员身份

检查商业票据智能合约： issue（发行），buy（购买），redeem（赎回）是PaperNet智能合约的三个核心功能。打开一个新的终端代表MagnetoCorp开发人员：

cd commercial-paper/organization/magnetocorp

在contract/lib下的papercontract.js查看智能合约，其中包含了商业票据智能合约，定义了发行、购买、赎回和查询等交易方法。将智能合约部署到通道：在应用程序调用papercontract之前，必须将合约安装到测试网络中合适的peer节点上，接着在通道上使用Fabric链码生命周期定义它，因此需要以MagnetoCorp和DigiBank的管理员的身份来安装和审批同意链码。一个链码中可以定义一个或多个智能合约，安装链码就使得PaperNet中不同组织可以使用其中的智能合约，同时也意味着只有管理员需要关注链码，其他人只需要关注智能合约。以 MagnetoCorp 的身份安装和批准智能合约：再打开一个命令端到cd commercial-paper/organization/magnetocorp下，管理员可以通过使用peer容器与PaperNet交互，还需要在命令窗口中设置一些环境变量，以使用正确的peer二进制文件，向MagneoCorp的peer节点的地址发送命令和使用正确的加密资料对请求进行签名：

# 打印完整环境变量并使用生效

source magnetocorp.sh

现在开始以管理员身份与网络交互：

1.安装papercontract智能合约使用peer lifecycle chaincode package将智能合约打包成链码

# 创建链码包

peer lifecycle chaincode package cp.tar.gz --lang node --path ./contract --label cp_0

使用peer lifecycle chaincode install命令在MagnetoCorp的peer节点上安装链码

peer lifecycle chaincode install cp.tar.gz

# 若报错，见附加问题6

2.同意（验证）链码定义先查询一下在peer上的链码的packageID：

peer lifecycle chaincode queryinstalled

接下来，需要把packageID保存为一个环境变量

export PACKAGE_ID=cp_0:ddca913c004eb34f36dfb0b4c0bcc6d4afc1fa823520bb5966a3bfcf1808f40a

再使用如下命令同意链码定义：

peer lifecycle chaincode approveformyorg --orderer localhost:7050 --ordererTLSHostnameOverride orderer.example.com --channelID mychannel --name papercontract -v 0 --package-id $PACKAGE_ID --sequence 1 --tls --cafile $ORDERER_CA

为了使用链码定义，通道成员需要同意最重要的链码参数之一是背书策略，背书策略描述了在确定交易有效之前必须背书的组织集合。通过不指定–policy标志而同意papercontract链码，我们在这里同意了使用通道的默认Endorsement策略——要求通道上大多数组织来背书交易，所有的交易无论有效与否都会被记录在区块链账本上，但只有有效的交易才会更新世界状态。

5.3 以 DigiBank 的身份

1.以 DigiBank 的身份安装和批准智能合约基于mychanner的LifecycleEndorsement策略，Fabric链码生命周期将要求通道上大多数组织将链码提交到通道之前同意链码的定义，即两者都同意（MagnetoCorp和DigiBank）。切换到digibank环境部署：

cd commercial-paper/organization/digibank/

source digibank.sh

现在以DigiBank的身份安装和同意papercontract，操作方法同MagnetoCorp相同：

# 打包链码

peer lifecycle chaincode package cp.tar.gz --lang node --path ./contract --label cp_0

# 安装链码

peer lifecycle chaincode install cp.tar.gz

# 查询安装链码的packageID

peer lifecycle chaincode queryinstalled

# 将id保存为环境变量

# export PACKAGE_ID=cp_0:

export PACKAGE_ID=cp_0:ddca913c004eb34f36dfb0b4c0bcc6d4afc1fa823520bb5966a3bfcf1808f40a

# Digibank管理员同意papercontract的链码定义：

至此，两个组织都同意了papernet链码，这也意味着通道上的客户端应用程序就可以调用papercontract链码中的ConmmercialPaper智能合约。在这里我们继续使用DigiBank管理员的身份操作，使用peer lifecycle chaincode commit命令将papercontract的链码定义提交到mychannel：

peer lifecycle chaincode commit -o localhost:7050 --ordererTLSHostnameOverride orderer.example.com --peerAddresses localhost:7051 --tlsRootCertFiles ${PEER0_ORG1_CA} --peerAddresses localhost:9051 --tlsRootCertFiles ${PEER0_ORG2_CA} --channelID mychannel --name papercontract -v 0 --sequence 1 --tls --cafile $ORDERER_CA --waitForEvent

可以看到两个peer节点上启动了papercontract容器，至此已经将papercontract代码部署到通道，接下来使用MagnetoCorp应用程序来发行商业票据。

5.4 应用结构

包含在 papercontract 中的智能合约由 MagnetoCorp 的应用程序 issue.js 调用，我们来看看cd commercial-paper/organization/magnetocorp/application，在这个目录下有个issue.js 从上图中看到代码前面定义了一些引入，现在我们把这些引入的包先安装下来：

# 切换目录

cd commercial-paper/organization/magnetocorp/application/

# 安装依，这个命令会把当前包下所有js文件中引入的依赖下载

npm install

# 查看目录

我们查看node_modules会发现已经安装了很多包，这是因为js-yaml 和 fabric-network 本身都被搭建在其他 npm 包中！package-lock.json 文件能准确识别已安装的版本。

5.5 钱包

因为 issue.js 代表 Isabella，所以也就代表 MagnetoCorp， issue.js 将会使用 Isabella 钱包中反应以上事实的身份。现在我们需要执行这个一次性的活动，向 Isabella 的钱包中添 X.509 证书。运行node enrollUser.js把身份信息添加到她的钱包中：我们再通过ls ../identity/user/isabella/wallet/查看钱包里有什么： Isabella可以在她的钱包中存储多个身份，但在我们的示例中，她只使用一个。 wallet文件夹里有一个isabella.id文件，该文件提供Isabella连接到网络所需的信息。

5.6 发行应用

Isabella 现在可以用 issue.js 来提交一项交易，该交易将发行 MagnetoCorp 商业票据 00001：

node issue.js

Process issue transaction response. {“class”:“org.papernet.commercialpaper”, “currentState”:1, “issuer”:“MagnetoCorp”, “paperNumber”:“00001”, “issueDateTime”:“2020-05-31”, “maturityDateTime”:“2020-11-30”, “faceValue”:5000000, “mspid”:“Org2MSP”, “owner”:“MagnetoCorp”}

5.7 DigiBank应用

现在我们使用DigiBank的身份来使用buy和redeem操作：

cd commercial-paper/organization/digibank/application/

详细看看这个目录下的两个文件操作过程和MagnetoCorp一样：

# 安装依赖

npm install

# 注册用户

node enrollUser.js

与Isabella一样，这里添加了一个balaji的身份信息到DigiBank的钱包中，用于买和赎交易，接下来我们来试试买和赎吧！

# 购买

node buy.js

# 赎回

node redeem.js

最后别忘了把这些数据都清理掉：

cd fabric-samples/commercial-paper

sudo ./network-clean.sh

如果你需要第二次执行，需要手动删除一些文件夹，比如digibank和magnetocorp下的identity文件夹，npm install的包node_moudle，只有删除了，第二次执行这些代码才能成功，又或者不再执行安装依赖的代码也可以。

附加问题

Got permission denied while trying to connect to the Docker daemon socket at… 解决办法：执行指令的账户没有权限，我在执行指令所使用的账户是普通账户，没有root权限,要么切换成root用户，要么把现在的用户加进来，一定要记得更新用户组！ #将用户添加到docker组，确保在用户命令下可以执行

sudo gpasswd -a $USER docker

#更新用户组

newgrp docker

curl: (7) Failed to connect to raw.githubusercontent.com port 443: 拒绝连接解决办法：打开网站: https://www.ipaddress.com/ 查询一下 raw.githubusercontent.com对应的IP 地址到命令行输入sudo vi /etc/hosts #添加一行：

#【查询到的任一 ip 】raw.githubusercontent.com，我这里是：

185.199.108.133 raw.githubusercontent.com

可能会失败，多试几次，我大概下载命令重复执行了6-8次才成功！ Chaincode installation on peer0.org1 has failed 超过执行的最后日期了 context deadline exceeded，可能其他操作也会造成这个，注意进行这些操作的时候一定要一气呵成，不要挂起虚拟机或者中断操作，否则会有一大堆问题，另一个，记住要备份，快照，这样就可以退回到上一个节点，避免重新删除改来改去。 Error: chaincode install failed with status: 500 - failed to invoke backing implementation of ‘InstallChaincode’: could not build chaincode: docker build failed: docker image build failed: docker build failed: Error returned from build: 1 "+ INPUT_DIR=/chaincode/input 错误：链码安装失败，状态：500 - 无法调用“InstallChaincode”的支持实现：无法构建链码：docker构建失败：docker映像构建失败：docker构建失败：从构建返回错误：1 “+ INPUT_DIR=/chaincode/input 这个问题就是docker构建出问题了，因为我之前挂起了虚拟机，docker容器没有重新启动，重新启动试试看： systemctl restart docker

Could not resolve host: github.com 拉取镜像发现这个问题，可能是网络没了，看看你右上角的网络图标还在吗？如果不在了，请执行以下命令： sudo service network-manager stop

sudo rm /var/lib/NetworkManager/NetworkManager.state

sudo gedit /etc/NetworkManager/NetworkManager.conf

#把false改成true，再重启网络

sudo service network-manager restart

peer lifecycle chaincode install cp.tar.gzError: chaincode install failed with status: 500 - failed to invoke backing implementation of ‘InstallChaincode’: could not build chaincode: docker build failed: docker image build failed: docker build failed: Error returned from build: 1 "+ INPUT_DIR=/chaincode/input+ OUTPUT_DIR=/chaincode/output+ cp -R /chaincode/input/src/. /chaincode/output+ cd /chaincode/output+ ‘[’ -f package-lock.json -o -f npm-shrinkwrap.json ]+ npm install --production npm ERR! code EAI_AGAIN npm ERR! errno EAI_AGAIN npm ERR! request to https://registry.npmjs.org/fabric-shim failed, reason: getaddrinfo EAI_AGAIN registry.npmjs.org npm ERR! A complete log of this run can be found in: npm ERR! /root/.npm/_logs/2022-05-24T06_09_07_419Z-debug.log 查了很多外网资料，都说是go的版本问题，换到go1.13即可，我之前用的是go1.18。

结语

以上就是所有官方示例的解析与操作，本人已经把官方教程的坑基本踩完，供各位新接触hyperledger fabric的朋友参考，后续学习以及本人即将要部署的区块链项目还会更新在区块链专题中。如有不对之处，欢迎指正；如有其他问题欢迎留言，如对您有帮助的话，请帮我点个赞！

关注博主即可阅读全文

优惠劵

做毕设的大企鹅

关注

踩

234

觉得还不错?

一键收藏

打赏

知道了

万字解析——区块链hyperledger fabric2.2部署实战教程

本文为官方文档解析，包含了network测试网络和两个实战示例。

复制链接

扫一扫

专栏目录

自然资源政务服务升级

qq_28605843的博客

03-12

315

1 背景概述... 1

1.1 自然资源系统政务服务“跨省通办”. 1

1.2 基于区块链的不动产登记电子证照应用服务... 1

1.3 “一码管地”实现自然资源内部业务贯通... 2

1.4 二三维一体化助力不动产登记... 3

2 建设意义... 3

3 目标和任务... 5

3.1 建设目标... 5

3.2 建设任务... 6

3.2.1 实现自然资源政务服务“跨省通办”. 6

3.2.2 建设基于区块链的不动产登记电子证照应用服务系统... 7

3.2.3 建设

区块链Hyperledger-Fabric实践日志.pdf

11-23

hyperledger fabric 环境搭建和学习实践记录

40 条评论

您还未登录，请先

后发表或查看评论

区块链项目实战——HyperLedger（超级账本）Fabric

01-19

区块链项目实战——HyperLedger（超级账本）Fabric

HyperLedger Fabric开发实战 - 部署单机多节点网络

张亚平的博客

12-29

1160

第3章部署单机多节点网络

亚马逊区块链搭建教程.pdf

06-29

AWS 区块链模板。利用这些模板只需几次点击，即可在几分钟内建立 Ethereum (公有或私有) 或 Hyperledger Fabric (私有) 网络。这些模板将会创建和配置所有必要的 AWS 资源，以保证稳健性和可扩展性。

Hyperledger Fabric 超级账本视频教程

11-14

Hyperledger Fabric 超级账本视频教程，区块链入门教程。

搭建Hyperledger Fabric环境的详细步骤，超级详细

目前专注区块链相关技术的学习与分享

07-03

1万+

本教程是跟着某硅谷三年前的视频一点点实现的。但是，跟着教程走，会出现很多视频里面没有出现过的问题，本文着重讲解搭建过程碰到的问题及解决方案！！1、安装docker （见我之前的教程）2、安装docker-compose3、安装Golang

4. 安装node.js5、安装Git最好先更新apt-get，否则可能会下载版本很旧的git，这是个好习惯，在下载任何包的时候，最好都更新一下工具下面的截图是我学习的教程里面的截图，但是在我操作的过程中会总有些镜像拉取不下来！原因：因为官方的sh文件存在版

Hyperledger Fabric 超级账本实战项目（十二）

qq_59508889的博客

01-15

558

链码的介绍

hyperledger fabric 2.3.3 搭建教程

【hyperledger fabric 教程】1.ubuntu 安装fabric并运行起来 - 知乎

【hyperledger fabric 教程】1.ubuntu 安装fabric并运行起来 - 知乎切换模式写文章登录/注册【hyperledger fabric 教程】1.ubuntu 安装fabric并运行起来喜欢蒂芙尼蓝不喜欢写论文又必须要写论文，喜欢摄影看剧又想搞视频的人儿。首先这篇文章的目的是教会大家如何在ubuntu系统上安装hyperledger fabric并运行起来，因为目前网络上所有的教程都是之前的fabric版本，然而现在的fabric版本相较于之前版本已经改变了很多，如果使用之前的方法来安装fabric是不能成功运行的。1.首先得有一台系统为ubuntu的服务器（centos其实操作原理差不多），推荐使用虚拟机安装ubuntu系统。2.更换apt的下载源，官方下载源很慢，我们需要更换到国内的镜像站2.1 进入 /etc/apt 目录cd /etc/apt 2.2 备份 sources.list 文件sudo cp /etc/apt/sources.list /etc/apt/sources.list_backup2.3 打开 sources.list 文件进行修改并添加阿里云镜像#在文件最前面添加即可

sudo vi /etc/apt/sources.list

# 阿里源

deb http://mirrors.aliyun.com/ubuntu/ bionic main restricted universe multiverse

deb http://mirrors.aliyun.com/ubuntu/ bionic-security main restricted universe multiverse

deb http://mirrors.aliyun.com/ubuntu/ bionic-updates main restricted universe multiverse

deb http://mirrors.aliyun.com/ubuntu/ bionic-proposed main restricted universe multiverse

deb http://mirrors.aliyun.com/ubuntu/ bionic-backports main restricted universe multiverse

deb-src http://mirrors.aliyun.com/ubuntu/ bionic main restricted universe multiverse

deb-src http://mirrors.aliyun.com/ubuntu/ bionic-security main restricted universe multiverse

deb-src http://mirrors.aliyun.com/ubuntu/ bionic-updates main restricted universe multiverse

deb-src http://mirrors.aliyun.com/ubuntu/ bionic-proposed main restricted universe multiverse

deb-src http://mirrors.aliyun.com/ubuntu/ bionic-backports main restricted universe multiverse2.4 对 apt-get 进行更新sudo apt-get update

sudo apt-get upgrade3. 环境安装我们需要安装的软件有 go docker docker-compose nodejs3.1 安装 go#进入根目录

cd ~

#下载压缩包

wget https://studygolang.com/dl/golang/go1.13.4.linux-amd64.tar.gz

#对压缩包解压

tar -xzf go1.13.4.linux-amd64.tar.gz

#删除压缩包

rm -rf go1.13.4.linux-amd64.tar.gz

#把根目录下的 go 文件夹移动到 /usr/local/ 目录下

mv go/ /usr/local/

#修改环境变量

vi ~/.bashrc

#GOROOT 路径是软件安装路径

export GOROOT=/usr/local/go

#GOPATH 路径是平时我们的工作路径，go项目放置在这个目录下

export GOPATH=$HOME/go

#添加到环境变量

export PATH=$PATH:/usr/local/go/bin

#退出 bashrc 文件然后更新环境变量

source ~/.bashrc

#使用 go version 可以查看go是否安装成功

go version

#go env 可以查看 go 的环境变量是否设置成功

go env3.2 安装 docker# 更新 apt 包索引

sudo apt-get update

# 下载安装工具

sudo apt-get install apt-transport-https ca-certificates software-properties-common

# 添加官方密钥

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -

# 加入 apt 仓库

sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable"

# 更新 apt 包索引

sudo apt-get update

# 安装 Docker-CE

sudo apt-get install docker-ce

# 验证版本

docker version

#将非root组加入 docker 组

sudo groupadd docker

sudo usermod -aG docker cigod

# 添加阿里云 Docker 镜像

sudo mkdir -p /etc/docker

sudo vi /etc/docker/daemon.json

#将下面内容添加到该文件中

{

"registry-mirrors": ["https://obou6wyb.mirror.aliyuncs.com"]

}

# 重启 Docker

sudo systemctl daemon-reload

sudo systemctl restart docker3.3 安装 docker-compose# 下载 docker-compose

sudo curl -L https://github.com/docker/compose/releases/download/1.26.0/docker-compose-$(uname -s)-$(uname -m) -o /usr/local/bin/docker-compose

# 允许其他用户执行compose相关命令

sudo chmod +x /usr/local/bin/docker-compose

# 验证版本

docker-compose -version3.4 安装 nodejs#请尽量避免在 Ubuntu 上使用 apt-get 来安装 node.js, 如果你已经这么做了，请手动移除

sudo apt-get purge nodejs && sudo apt-get autoremove && sudo apt-get autoclean

#使用 nvm 来安装

curl -o- https://raw.githubusercontent.com/creationix/nvm/v0.33.11/install.sh | bash

#查看 nvm 是否安装成功

nvm --version

#查看 nodejs 可以安装的所有版本

nvm ls-remote

#目前 nodejs 最新的长期支持版为 12.18.2

nvm install 12.18.2

#查看 nodejs 版本

node -v4. 获取 bootstrap.sh 文件首先解决 git clone 速度慢的问题在网站 https://www.ipaddress.com/ 分别搜索域名，然后得到他们的ip地址

github.global.ssl.fastly.net

github.com

#以下截图为目前两个网址的 ip 地址，用户需根据自己查到的 ip 地址进行修改#打开 hosts 文件

vi /etc/hosts

#修改 hosts 文件，在文件末尾添加以下内容

199.232.69.194 github.global-ssl.fastly.net

140.82.113.3 github.com

#退出文件，然后更新 DNS

sudo /etc/init.d/networking restart

#创建目录

mkdir -p /root/go/src/github.com/hyperledger

#进入该目录

cd /root//go/src/github.com/hyperledger

#下载fabric，使用这个地址下载速度要快很多，我在虚拟机上能达到 2M/S，因为这个fabric的包挺大，

所以需要等一段时间

git clone https://github.com.cnpmjs.org/hyperledger/fabric.git

#下载完 fabric 后，bootstrap.sh 就在 fabric 目录下的 scripts 文件夹中如果使用 git clone https://github.com.cnpmjs.org/hyperledger/fabric.git 这个命令后确实速度非常慢，那么可以使用下面的方法获取 bootstrap.sh 文件，已经下载好 fabric 的则不需要单独下载 bootstrap.sh打开网站 https://www.ipaddress.com/ 搜索域名 raw.githubusercontent.com 的ip 地址

因为 ip 地址可能改变，所以用户需要将自己查到的 ip 地址放上去

#打开 hosts 文件

vi /etc/hosts

#修改 hosts 文件，在文件末尾添加以下内容，注意其中的 ip 地址应该改成用户所查到的 ip

199.232.68.133 raw.githubusercontent.com

#退出文件，然后更新 DNS

sudo /etc/init.d/networking restart

#创建目录

mkdir -p /root/go/src/github.com/hyperledger/fabric

#进入该目录

cd /root//go/src/github.com/hyperledger/fabric

#手工下载 bootstrap.sh

wget https://raw.githubusercontent.com/hyperledger/fabric/master/scripts/bootstrap.sh

#修改权限

chmod u+x bootstrap.sh5. 运行 bootstrap.sh 文件因为这个文件中需要下载一些二进制的文件，但是这些文件又存放在国外的网站上，所以下载速度非常慢，所以不能通过直接运行 bootstrap.sh 文件来安装 fabric 所需的工具和镜像。通过查看该文件发现该文件主要做了三件事，1.下载 fabric-samples 到 fabric 目录下，2.下载相关的二进制文件，3.下载相关的 docker 镜像，所以我们可以手动来完成这三个步骤5.1 下载 fabric-samples 到 fabric 目录下#进入该目录

cd /root//go/src/github.com/hyperledger/fabric

#下载 fabric-samples

git clone https://github.com.cnpmjs.org/hyperledger/fabric-samples.git5.2 下载相关的二进制文件首先打开 bootstrap.sh 查看两个二进制文件的版本，目前最新的版本是 2.2.0 和 1.4.7，两个二进制文件的下载地址为（注意：根据自己查看bootstrap.sh文件得到相应版本号，从而修改地址其中的版本号）：https://github.com/hyperledger/fabric/releases/download/v2.2.0/hyperledger-fabric-linux-amd64-2.2.0.tar.gz

https://github.com/hyperledger/fabric-ca/releases/download/v1.4.7/hyperledger-fabric-ca-linux-amd64-1.4.7.tar.gz我已经把这两个文件放在百度网盘中了，要的可以自取（地址，提取码：zn0v）如果大家想自己下载最新的版本最好使用 IDM（Internet Download Manager）下载。然后大家可以通过 filezilla 软件或者其他软件把这两个文件放到 /root/go/src/http://github.com/hyperledger/fabric/fabric-samples/ 这个目录下面#在该目录下面解压这两个压缩包

tar -xzf hyperledger-fabric-linux-amd64-2.2.0.tar.gz

tar -xzf hyperledger-fabric-ca-linux-amd64-1.4.7.tar.gz解压完成之后会在这个目录下面生成一个 /bin 文件夹，bin目录下面存放的都是一些生成fabric网络所需的工具，到目前为止，bootstrap 文件中的第二个步骤已经弄完了，下面进行第三个步骤5.3.下载docker镜像回到放置 bootstrap.sh 文件的目录下面，然后执行下面的命令#该命令会下载所需的 docker 镜像

./bootstrap.sh -s -b下载完成后，会看到终端输出已安装的 docker 镜像到目前为止，运行 fabric 网络所需的工具都已安装，下面进行第一次网络的运行。6. 运行 fabric 网络#进入下面这个目录

cd /root/go/src/github.com/hyperledger/fabric/fabric-samples/test-network

#使用该命令启动网络

./network.sh up启动成功后，会输出正在运行的三个 docker 容器。到这里，就已经完成了 fabric 的安装和第一次运行，后面还会继续推出关于 fabric 系列的文章，敬请期待！#网络运行完成后，使用如下命令关闭网络

./network.sh down编辑于 2020-07-11 10:59Go 语言区块链(Blockchain)Hyperledger赞同 5013 条评论分享喜欢收藏申请

入门 — hyperledger-fabricdocs master 文档

hyperledger-fabricdocs

latest

我们是谁

介绍

Hyperledger Fabric v2.0 更新说明

发行说明

关键概念

入门

准备阶段

使用Fabric的测试网络

Hyperledger Fabric 智能合约（链码） API

Hyperledge Fabric 应用程序 SDK

Hyperledger Fabric CA

开发应用

教程

部署一个生产网络

操作指南

升级到最新版本

命令参考

架构参考

常见问题

欢迎贡献！

术语表

版本发布

仍有问题？

状态

hyperledger-fabricdocs

入门

Edit on GitHub

入门¶

在我们开始之前，如果您还没有这样做，您可能希望检查您是否已经在将要开发区块链应用程序或运行 Hyperledger Fabric 的平台上安装了所有准备阶段。

安装必备组件后，即可下载并安装 HyperLedger Fabric。在我们为Fabric 二进制文件开发真正的安装程序的同时，我们提供了一个脚本，可以将到您的系统中。该脚本还将 Docker 镜像下载到本地注册表。

在你下载完 Fabric 示例以及 Docker 镜像到你本机之后，您就可以跟着使用Fabric的测试网络教程开始使用 Fabric 了。

Hyperledger Fabric 智能合约（链码） API¶

Hyperledger Fabric 提供了不同编程语言的 API 来支持开发智能合约（链码）。智能合约 API 可以使用 Go、Node.js 和 Java：

Go 合约 API 。

Node.js 合约 API and Node.js 合约 API 文档。

Java 合约 API and Java 合约 API 文档。

Hyperledge Fabric 应用程序 SDK¶

Hyperledger Fabric 提供了许多 SDK 来支持各种编程语言开发应用程序。SDK 有支持 Node.js 和 Java 语言的：

Node.js SDK and Node.js SDK 文档。

Java SDK and Java SDK 文档。

此外，还有两个尚未正式发布的 SDK（Python 和 Go），但它们仍可供下载和测试：

Python SDK.

Go SDK.

目前，Node.js、Java 和 Go 支持 Hyperledge Fabric 1.4 提供的新的应用程序编程模型。

Hyperledger Fabric CA¶

Hyperledger Fabric 提供一个可选的证书授权服务，您可以选择使用该服务生成证书和密钥材料，以配置和管理区块链网络中的身份。然而，任何可以生成 ECDSA 证书的 CA 都是可以使用的。

This work is licensed under a Creative Commons Attribution 4.0 International License

Revision b9b6b2b6.

Built with Sphinx using a theme provided by Read the Docs.

Read the Docs

v: latest

Versions

latest

release-2.5

fabric-ca-release1.4

Downloads

html

On Read the Docs

Project Home

Builds

编写第一个应用 - Hyperledger中文文档

Hyperledger中文文档

欢迎

词汇表

简介

快速入门

协议规范

Fabric教程

构建第一个fabric网络

编写第一个应用

编写第一个应用(Writing Your First Application)

下载测试网络（Getting a Test Network）

应用程序如何与网络进行交互(How Applications Interact with the Network)

查询账本(Querying the Ledger)

更新账本(Updating the Ledger)

其他资源(Additional Resources)

Chaincode 指南

Chaincode 开发手册

Chaincode 操作手册

Fabric操作指南

MSP

Channel 配置(configtx)

Channel 配置(configtxgen)

Channel 重新配置(configtxlator)

背书策略

错误处理

日志控制

Fabric设计

架构说明

交易流程

SDK--node

SDK--java

基于kafka的排序服务

Channels

账本

Read-Write set

Gossip数据传输协议

故障排除和常见问题

Hyperledger Fabric 答疑

MSP&ACL

Fabric SDK 设计

Makefile文件解析

BCCSP密码算法套件解析

Zanata使用指南

Hyperledger中文文档

Docs »

Fabric教程 »

编写第一个应用

Edit on GitHub

原文

作者

审核修正

原文

Qiang Sheng

编写第一个应用(Writing Your First Application)¶

The goal of this document is to show the tasks and provide a baseline for writing your first application against a Hyperledger Fabric network.

本文档将会指引您基于Hyperledger Fabric网络编写第一个应用程序。

At the most basic level, applications on a blockchain network are what enable users to query a ledger (asking for specific records it contains), or to update it (adding records to it).

最基本的，区块链网络应用程序需要提供给用户查询账本（包含特定记录）以及更新账本（添加记录）的功能。

Our application, composed in Javascript, leverages the Node.js SDK to interact with the network (where our ledger exists). This tutorial will guide you through the three steps involved in writing your first application.

我们的应用程序基于Javascript，通过Node.js SDK与（账本所在的）网络进行交互。本教程将通过三步来指导您编写您的第一个应用程序。

1. Starting a test Hyperledger Fabric blockchain network. We need some basic components in our network in order to query and update the ledger. These components – a peer node, ordering node and Certificate Authority – serve as the backbone of our network; we’ll also have a CLI container used for a few administrative commands. A single script will download and launch this test network.

1. 启动一个Hyperledger Fabric区块链测试网络。在我们的网络中，我们需要一些最基本的组件来查询和更新账本。这些组件 —— peer节点、ordering节点以及证书管理 —— 是我们网络的基础。而CLI容器则用来发送一些管理命令。有个简单的脚本将下载并启动这个测试网络。

2. Learning the parameters of the sample smart contract our app will use. Our smart contracts contain various functions that allow us to interact with the ledger in different ways. For example, we can read data holistically or on a more granular level.

2. 学习应用程序中所用到的智能合约例子的参数。智能合约包含的各种功能让我们可以用多种方式和账本进行交互。如，我们可以读取整体的数据或者某一部分详尽的数据。

3. Developing the application to be able to query and update records. We provide two sample applications – one for querying the ledger and another for updating it. Our apps will use the SDK APIs to interact with the network and ultimately call these functions.

3. 开发能够查询以及更新记录的应用程序。我们提供两个程序例子 —— 一个用于查询账本，另一个用户更新账本。我们的程序将使用SDK APIs来和网络进行交互，并最终调用这些功能。

After completing this tutorial, you should have a basic understanding of how an application, using the Hyperledger Fabric SDK for Node.js, is programmed in conjunction with a smart contract to interact with the ledger on a Hyperledger Fabric network.

完成本教程之后，您应该会基本了解一个使用Hyperledger Fabric Node.js SDK并带有智能合约的应用程序，是如何与Hyperledger Fabric网络中的账本进行交互的。

First, let’s launch our test network…

首先，让我们启动测试网络…

下载测试网络（Getting a Test Network）¶

Visit the Prerequisites page and ensure you have the necessary dependencies installed on your machine.

请先访问Prerequisites网页并确保您的计算机上已经安装了必需的依赖项。

Now determine a working directory where you want to clone the fabric-samples repo. Issue the clone command and change into the fabcar subdirectory

选择clone fabric-samples的工作目录，运行clone命令，并进入fabcar子目录

git clone https://github.com/hyperledger/fabric-samples.git

cd fabric-samples/fabcar

This subdirectory – fabcar– contains the scripts and application code to run the sample app. Issue an ls from this directory. You should see the following:

这个子目录 - fabcar - 包含运行示例程序的脚本以及程序代码。在该目录运行ls命令，您应该会看到以下内容：

chaincode invoke.js network package.json query.js startFabric.sh

Now use the startFabric.sh script to launch the network.

现在调用startFabric.sh来启动网络。

Note

The following command downloads and extracts the Hyperledger Fabric Docker images, so it will take a few minutes to complete.

请注意：下面命令将会下载并解压Hyperledger Fabric Docker images，因此需要几分钟时间来完成。

./startFabric.sh

For the sake of brevity, we won’t delve into the details of what’s happening with this command. Here’s a quick synopsis:

为了简洁起见，我们不会深入了解这个命令的具体细节。下面是一个关于这个命令的快速简要说明：

launches a peer node, ordering node, Certificate Authority and CLI container

creates a channel and joins the peer to the channel

installs smart contract (i.e. chaincode) onto the peer’s file system and instantiates said chaincode on the channel; instantiate starts a chaincode container

calls the initLedger function to populate the channel ledger with 10 unique cars

启动peer节点、Ordering节点、证书颁发机构以及CLI容器

创建一个通道，并将peer加入该通道

将智能合约（即链码）安装到peer节点的文件系统上，并在通道上实例化该链码；实例化会启动链码容器

调用initLedger功能来向通道账本写入10个不同的汽车

Note

These operations will typically be done by an organizational or peer admin. The script uses the CLI to execute these commands, however there is support in the SDK as well. Refer to the Hyperledger Fabric Node SDK repo for example scripts.

请注意：这些操作通常由组织或者peer的管理员来完成。这个脚本使用CLI容器来执行这些命令，但SDK中也有支持。具体请参阅Hyperledger Fabric Node SDK repo中的示例脚本。

Issue a docker ps command to reveal the processes started by the startFabric.sh script. You can learn more about the details and mechanics of these operations in the Building Your First Network section. Here we’ll just focus on the application. The following picture provides a simplistic representation of how the application interacts with the Hyperledger Fabric network.

发送docker ps命令可以显示startFabric.sh脚本启动的进程。您可以在Building Your First Network部分了解有关这些操作的详细信息和机制。在这里，我们专注于应用程序。下图简单描述了一个应用程序与Hyperledger Fabric网络交互的过程。

Alright, now that you’ve got a sample network and some code, let’s take a look at how the different pieces fit together.

好了，现在我们有了简单的网络以及一些代码，现在看看他们是怎么一起工作的。

应用程序如何与网络进行交互(How Applications Interact with the Network)¶

Applications use APIs to invoke smart contracts (referred to as “chaincode”). These smart contracts are hosted in the network and identified by name and version. For example, our chaincode container is titled - dev-peer0.org1.example.com-fabcar-1.0 - where the name is fabcar, the version is 1.0 and the peer it is running against is dev-peer0.org1.example.com.

应用程序使用APIs来调用智能合约(即“链码”)。这些智能合同托管在网络中，并通过名称和版本进行标识。例如，标示为dev-peer0.org1.example.com-fabcar-1.0的容器，其名称是fabcar，版本号是1.0，运行peer是dev-peer0.org1.example.com。

APIs are accessible with a software development kit (SDK). For purposes of this exercise, we’ll be using the Hyperledger Fabric Node SDK though there is also a Java SDK and CLI that can be used to develop applications.

API可通过软件开发工具包（SDK）访问。在本练习中，我们将使用Hyperledger Fabric Node SDK，除此以外，Fabric还提供了Java SDK和CLI用于开发应用程序。

查询账本(Querying the Ledger)¶

Queries are how you read data from the ledger. You can query for the value of a single key, multiple keys, or – if the ledger is written in a rich data storage format like JSON – perform complex searches against it (looking for all assets that contain certain keywords, for example).

查询是指如何从账本中读取数据。您可以查询单个或者多个键的值，如果账本是以类似于JSON这样的数据存储格式写入的，则可以执行更复杂的搜索（如查找包含某些关键字的所有资产）。

As we said earlier, our sample network has an active chaincode container and a ledger that has been primed with 10 different cars. We also have some sample Javascript code - query.js - in the fabcar directory that can be used to query the ledger for details on the cars.

正如我们前面所说，我们的示例网络有一个活跃的链码容器和一个已经包含10种不同汽车的账本。我们还有一些示例Javascript代码，我们可以使用fabcar目录中的query.js来查询账本中关于车的详细信息。

Before we take a look at how that app works, we need to install the SDK node modules in order for our program to function. From your fabcar directory, issue the following:

在我们查看该应用程序的工作原理之前，我们需要安装SDK模块才能让程序运行。在fabcar目录中，运行下面的命令：

npm install

Note

You will issue all subsequent commands from the fabcar directory.

请注意：后续命令也都是在fabcar目录中运行。

Now we can run our javascript programs. First, let’s run our query.js program to return a listing of all the cars on the ledger. A function that will query all the cars, queryAllCars, is pre-loaded in the app, so we can simply run the program as is:

现在我们可以运行JavaScript程序。首先，运行query.js 程序，返回账本上所有汽车列表。应用程序中预先加载了一个queryAllCars函数，用于查询所有车辆，因此我们可以简单地运行程序：

node query.js

It should return something like this:

返回应如下：

Query result count = 1

Response is [{"Key":"CAR0", "Record":{"colour":"blue","make":"Toyota","model":"Prius","owner":"Tomoko"}},

{"Key":"CAR1", "Record":{"colour":"red","make":"Ford","model":"Mustang","owner":"Brad"}},

{"Key":"CAR2", "Record":{"colour":"green","make":"Hyundai","model":"Tucson","owner":"Jin Soo"}},

{"Key":"CAR3", "Record":{"colour":"yellow","make":"Volkswagen","model":"Passat","owner":"Max"}},

{"Key":"CAR4", "Record":{"colour":"black","make":"Tesla","model":"S","owner":"Adriana"}},

{"Key":"CAR5", "Record":{"colour":"purple","make":"Peugeot","model":"205","owner":"Michel"}},

{"Key":"CAR6", "Record":{"colour":"white","make":"Chery","model":"S22L","owner":"Aarav"}},

{"Key":"CAR7", "Record":{"colour":"violet","make":"Fiat","model":"Punto","owner":"Pari"}},

{"Key":"CAR8", "Record":{"colour":"indigo","make":"Tata","model":"Nano","owner":"Valeria"}},

{"Key":"CAR9", "Record":{"colour":"brown","make":"Holden","model":"Barina","owner":"Shotaro"}}]

These are the 10 cars. A black Tesla Model S owned by Adriana, a red Ford Mustang owned by Brad, a violet Fiat Punto owned by someone named Pari, and so on. The ledger is key/value based and in our implementation the key is CAR0 through CAR9. This will become particularly important in a moment.

这里有10辆车，一辆属于Adriana的黑色Tesla Model S、一辆属于Brad的红色Ford Mustang、一辆属于Pari的紫罗兰色Fiat Punto等等。账本是基于Key/Value 的，在这里，关键字是从CAR0到CAR9。这一点特别重要。

Now let’s see what it looks like under the hood (if you’ll forgive the pun). Use an editor (e.g. atom or visual studio) and open the query.js program.

现在让我们来看看代码内容。使用编辑器（例如atom或visual studio）打开query.js程序。

The inital section of the application defines certain variables such as chaincode ID, channel name and network endpoints:

应用程序的初始部分定义了变量，如链码，通道名称和网络端点：

var options = {

wallet_path : path.join(__dirname, './network/creds'),

user_id: 'PeerAdmin',

channel_id: 'mychannel',

chaincode_id: 'fabcar',

network_url: 'grpc://localhost:7051',

This is the chunk where we construct our query:

这是构建查询的代码块：

// queryCar - requires 1 argument, ex: args: ['CAR4'],

// queryAllCars - requires no arguments , ex: args: [''],

const request = {

chaincodeId: options.chaincode_id,

txId: transaction_id,

fcn: 'queryAllCars',

args: ['']

We define the chaincode_id variable as fabcar – allowing us to target this specific chaincode – and then call the queryAllCars function defined within that chaincode.

我们将chaincode_id变量赋值为fabcar- 这让我们定位到这个特定的链码 - 然后调用该链码中定义的queryAllCars函数。

When we issued the node query.js command earlier, this specific function was called to query the ledger. However, this isn’t the only function that we can pass.

在前面，我们发出node query.js命令时，会调用了特定函数来查询账本。但是，这不是我们能够使用的唯一功能。

To take a look at the others, navigate to the chaincode subdirectory and open fabcar.go in your editor. You’ll see that we have the following functions available to call - initLedger, queryCar, queryAllCars, createCar and changeCarOwner. Let’s take a closer look at the queryAllCars function to see how it interacts with the ledger.

要查看其他，请转至到chaincode子目录并在编辑器中打开fabcar.go。你会看到，我们可以调用下面的函数- initLedger、queryCar、queryAllCars、createCar和changeCarOwner。让我们仔细看看queryAllCars函数是如何与账本进行交互的。

func (s *SmartContract) queryAllCars(APIstub shim.ChaincodeStubInterface) sc.Response {

startKey := "CAR0"

endKey := "CAR999"

resultsIterator, err := APIstub.GetStateByRange(startKey, endKey)

The function uses the shim interface function GetStateByRange to return ledger data between the args of startKey and endKey. Those keys are defined as CAR0 and CAR999 respectively. Therefore, we could theoretically create 1,000 cars (assuming the keys are tagged properly) and a queryAllCars would reveal every one.

该函数调用shim接口函数GetStateByRange来返回参数在startKey和endKey间的账本数据。这两个键值分别定义为CAR0和CAR999。因此，我们理论上可以创建1,000辆汽车（假设Keys都被正确使用），queryAllCars函数将会显示出每一辆汽车的信息。

Below is a representation of how an app would call different functions in chaincode.

下图演示了一个应用程序如何在链码中调用不同功能。

We can see our queryAllCars function up there, as well as one called createCar that will allow us to update the ledger and ultimately append a new block to the chain. But first, let’s do another query.

我们可以看到我们用过的queryAllCars函数，还有一个叫做createCar，这个函数可以让我们更新账本，并最终在链上增加一个新区块。但首先，让我们做另外一个查询。

Go back to the query.js program and edit the constructor request to query a specific car. We’ll do this by changing the function from queryAllCars to queryCar and passing a specific “Key” to the args parameter. Let’s use CAR4 here. So our edited query.js program should now contain the following:

现在我们返回query.js程序并编辑请求构造函数以查询特定的车辆。为达此目的，我们将函数queryAllCars更改为queryCar并将特定的“Key” 传递给args参数。在这里，我们使用CAR4。所以我们编辑后的query.js程序现在应该包含以下内容：

const request = {

chaincodeId: options.chaincode_id,

txId: transaction_id,

fcn: 'queryCar',

args: ['CAR4']

Save the program and navigate back to your fabcar directory. Now run the program again:

保存程序并返回fabcar目录。现在再次运行程序：

node query.js

You should see the following:

您应该看到以下内容：

{"colour":"black","make":"Tesla","model":"S","owner":"Adriana"}

So we’ve gone from querying all cars to querying just one, Adriana’s black Tesla Model S. Using the queryCar function, we can query against any key (e.g. CAR0) and get whatever make, model, color, and owner correspond to that car.

这样，我们就从查询所有车变成了只查询一辆车：Adriana的黑色Tesla Model S。使用queryCar函数，我们可以查询任意关键字（例如CAR0），并获得与该车相对应的制造厂商、型号、颜色和所有者。

Great. Now you should be comfortable with the basic query functions in the chaincode, and the handful of parameters in the query program. Time to update the ledger…

很好，现在您应该比较熟悉该链码的基本查询功能以及带参数的查询功能了。现在是时候更新账本了…

更新账本(Updating the Ledger)¶

Now that we’ve done a few ledger queries and added a bit of code, we’re ready to update the ledger. There are a lot of potential updates we could make, but let’s just create a new car for starters.

我们已经完成了几个分类帐查询并添加了一些代码，现在更新账本。我们可以做很多更新动作，首先让我们为新手创建一辆新车。

Ledger updates start with an application generating a transaction proposal. Just like query, a request is constructed to identify the channel ID, function, and specific smart contract to target for the transaction. The program then calls the channel.SendTransactionProposal API to send the transaction proposal to the peer(s) for endorsement.

账本更新是从生成交易提案的应用程序开始的。就像查询一样，我们将会构造一个请求，用来识别要进行交易的通道ID、函数以及智能合约。该程序然后调用channel.SendTransactionProposalAPI将交易建议发送给peer(s)进行认证。

The network (i.e. endorsing peer) returns a proposal response, which the application uses to build and sign a transaction request. This request is sent to the ordering service by calling the channel.sendTransaction API. The ordering service will bundle the transaction into a block and then “deliver” the block to all peers on a channel for validation. (In our case we have only the single endorsing peer.)

网络（即endorsing peer）返回一个提案答复，应用程序以此来创建和签署交易请求。该请求通过调用channel.sendTransaction API发送到排序服务器。排序服务器将把交易打包进区块，然后将区块“发送”到通道上的所有peers进行认证。（在我们的例子中，我们只有一个endorsing peer。）

Finally the application uses the eh.setPeerAddr API to connect to the peer’s event listener port, and calls eh.registerTxEvent to register events associated with a specific transaction ID. This API allows the application to know the fate of a transaction (i.e. successfully committed or unsuccessful). Think of it as a notification mechanism.

最后，应用程序使用eh.setPeerAddr API连接到peer的事务监听端口，并调用eh.registerTxEvent注册与特定交易ID相关联的事务。该API使得应用程序获得事务的结果（即成功提交或不成功）。把它当作一个通知机制。

Note

We don’t go into depth here on a transaction’s lifecycle. Consult the Transaction Flow documentation for lower level details on how a transaction is ultimately committed to the ledger.

请注意：这里我们不深入讨论交易细节。有关交易如何最终提交给账本的详细信息，请参阅交易流程文档。

The goal with our initial invoke is to simply create a new asset (car in this case). We have a separate javascript program - invoke.js - that we will use for these transactions. Just like query, use an editor to open the program and navigate to the codeblock where we construct our invocation:

我们初始调用的目标是简单地创建一个新的资产（这里为汽车）。我们有一个独立的用于这些交易的JavaScript程序 - invoke.js。就像查询一样，使用编辑器打开程序并转到构建调用的代码块：

// createCar - requires 5 args, ex: args: ['CAR11', 'Honda', 'Accord', 'Black', 'Tom'],

// changeCarOwner - requires 2 args , ex: args: ['CAR10', 'Barry'],

// send proposal to endorser

var request = {

targets: targets,

chaincodeId: options.chaincode_id,

fcn: '',

args: [''],

chainId: options.channel_id,

txId: tx_id

You’ll see that we can call one of two functions - createCar or changeCarOwner. Let’s create a red Chevy Volt and give it to an owner named Nick. We’re up to CAR9 on our ledger, so we’ll use CAR10 as the identifying key here. The updated codeblock should look like this:

我们可以调用函数createCar或者changeCarOwner。首先我们创建一个红色的Chevy Volt，并把它归属于Nick。在账本中我们的Key值已经用到了CAR9 ，所以这里我们将使用CAR10。更新代码块如下：

var request = {

targets: targets,

chaincodeId: options.chaincode_id,

fcn: 'createCar',

args: ['CAR10', 'Chevy', 'Volt', 'Red', 'Nick'],

chainId: options.channel_id,

txId: tx_id

Save it and run the program:

保存并运行程序：

node invoke.js

There will be some output in the terminal about Proposal Response and Transaction ID. However, all we’re concerned with is this message:

终端将会输出一些提案响应和交易ID。但是，我们关心的是这个：

The transaction has been committed on peer localhost:7053

The peer emits this event notification, and our application receives it thanks to our eh.registerTxEvent API. So now if we go back to our query.js program and call the queryCar function against an arg of CAR10, we should see the following:

peer发出此事务通知，我们的应用程序通过 eh.registerTxEventAPI接收到该通知。现在，如果我们回到query.js程序并调用带有CAR10参数的queryCar函数，将会看到：

Response is {"colour":"Red","make":"Chevy","model":"Volt","owner":"Nick"}

Finally, let’s call our last function - changeCarOwner. Nick is feeling generous and he wants to give his Chevy Volt to a man named Barry. So, we simply edit invoke.js to reflect the following:

最后，我们来调用最后一个函数changeCarOwner。Nick很慷慨，他想把他的Chevy Volt送给Barry。所以，我们简单编辑invoke.js 如下：

var request = {

targets: targets,

chaincodeId: options.chaincode_id,

fcn: 'changeCarOwner',

args: ['CAR10', 'Barry'],

chainId: options.channel_id,

txId: tx_id

Execute the program again - node invoke.js - and then run the query app one final time. We are still querying against CAR10, so we should see:

再次运行node invoke.js，之后再运行查询程序，我们仍然是使用CAR10作为参数查询，将会看到如下结果：

Response is {"colour":"Red","make":"Chevy","model":"Volt","owner":"Barry"}

其他资源(Additional Resources)¶

The Hyperledger Fabric Node SDK repo is an excellent resource for deeper documentation and sample code. You can also consult the Hyperledger Fabric community and component experts on Hyperledger Rocket Chat.

在Hyperledger Fabric Node SDK repo可以找到更多的说明文档以及代码例子。您也可以在Hyperledger Rocket Chat上咨询Hyperledger Fabric社区专家。

Hyperledger国际化工作组(yls@chainnova.com)

Built with MkDocs using a theme provided by Read the Docs.

GitHub

« Previous

快速入门 - Hyperledger中文文档

Hyperledger中文文档

欢迎

词汇表

简介

快速入门

前提

执行完整脚本

清理

configtxgen

执行generateCfgTrx.sh脚本

启动网络

背后发生了什么？

这表明了什么？

查看交易

查看chaincode日志

手动执行交易

修改docker-compose文件

命令语法

Create channel

Join channel

Install chaincode

Instantiate chaincode

Invoke chaincode

Query chaincode

手动构建镜像

使用本地二进制文件

终端1

终端2

终端1

终端3

Create channel

Join channel

Install chaincode

Instantiate chaincode

Invoke chaincode

Query chaincode

使用CouchDB

数据持久化

故障排出

协议规范

Fabric教程

构建第一个fabric网络

编写第一个应用

Chaincode 指南

Chaincode 开发手册

Chaincode 操作手册

Fabric操作指南

MSP

Channel 配置(configtx)

Channel 配置(configtxgen)

Channel 重新配置(configtxlator)

背书策略

错误处理

日志控制

Fabric设计

架构说明

交易流程

SDK--node

SDK--java

基于kafka的排序服务

Channels

账本

Read-Write set

Gossip数据传输协议

故障排除和常见问题

Hyperledger Fabric 答疑

MSP&ACL

Fabric SDK 设计

Makefile文件解析

BCCSP密码算法套件解析

Zanata使用指南

Hyperledger中文文档

Docs »

快速入门

Edit on GitHub

原文

作者

审核修正

原文

Linsheng Yu

Kewei Sun

本文设定了一个简单的Fabric网络场景，包括2个organization，每个有2个peer，并使用“solo” ordering服务。网络实体所需的加密材料（x509证书）已预先生成并放到相应目录和配置文件里了，你无需修改这些配置。examples/e2e_cli文件夹里包含了docker-compose文件和要用来创建和测试网络的脚本文件。

本文还演示了使用配置生成工具configtxgen生成网络配置。

前提¶

完成以下安装Fabric源码和编译configtxgen工具：

完成环境安装，并设置正确的$GOPATH环境变量。

拉取Fabric源码

git clone https://github.com/hyperledger/fabric.git

编译configtxgen工具

如果运行在Linux，在Fabric目录下执行以下命令：

cd $GOPATH/src/github.com/hyperledger/fabric

make configtxgen

# 如果出错：'ltdl.h' file not found

sudo apt install libtool libltdl-dev

# 然后再运行make

make configtxgen

如果运行在OSX，先安装Xcode 8.0或以上版本，然后在Fabric目录下执行以下命令：

# 安装 Homebrew

/usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"

# 添加 gnu-tar

brew install gnu-tar --with-default-names

# 添加 libtool

brew install libtool

# 编译 configtxgen

make configtxgen

编译成功后输出：

build/bin/configtxgen

CGO_CFLAGS=" " GOBIN=/Users/johndoe/work/src/github.com/hyperledger/fabric/build/bin go install -ldflags "-X github.com/hyperledger/fabric/common/metadata.Version=1.0.0-snapshot-8d3275f -X github.com/hyperledger/fabric/common /metadata.BaseVersion=0.3.0 -X github.com/hyperledger/fabric/common/metadata.BaseDockerLabel=org.hyperledger.fabric" github.com/hyperledger/fabric/common/configtx/tool/configtxgen

Binary available as build/bin/configtxgen``

编译后执行文件放在Fabric目录下的的build/bin/configtxgen

执行完整脚本¶

为了加快部署过程，我们提供了一个脚本来执行所有任务。执行该脚本会生成配置结果、本地网络、Chaincode测试。

进入examples/e2e_cli目录，首先从Docker Hub拉取镜像：

# 使脚本可执行

chmod +x download-dockerimages.sh

# 执行脚本

./download-dockerimages.sh

这个过程会需要几分钟，脚本执行后输出：

===> List out hyperledger docker images

hyperledger/fabric-ca latest 35311d8617b4 7 days ago 240 MB

hyperledger/fabric-ca x86_64-1.0.0-alpha 35311d8617b4 7 days ago 240 MB

hyperledger/fabric-couchdb latest f3ce31e25872 7 days ago 1.51 GB

hyperledger/fabric-couchdb x86_64-1.0.0-alpha f3ce31e25872 7 days ago 1.51 GB

hyperledger/fabric-kafka latest 589dad0b93fc 7 days ago 1.3 GB

hyperledger/fabric-kafka x86_64-1.0.0-alpha 589dad0b93fc 7 days ago 1.3 GB

hyperledger/fabric-zookeeper latest 9a51f5be29c1 7 days ago 1.31 GB

hyperledger/fabric-zookeeper x86_64-1.0.0-alpha 9a51f5be29c1 7 days ago 1.31 GB

hyperledger/fabric-orderer latest 5685fd77ab7c 7 days ago 182 MB

hyperledger/fabric-orderer x86_64-1.0.0-alpha 5685fd77ab7c 7 days ago 182 MB

hyperledger/fabric-peer latest 784c5d41ac1d 7 days ago 184 MB

hyperledger/fabric-peer x86_64-1.0.0-alpha 784c5d41ac1d 7 days ago 184 MB

hyperledger/fabric-javaenv latest a08f85d8f0a9 7 days ago 1.42 GB

hyperledger/fabric-javaenv x86_64-1.0.0-alpha a08f85d8f0a9 7 days ago 1.42 GB

hyperledger/fabric-ccenv latest 91792014b61f 7 days ago 1.29 GB

hyperledger/fabric-ccenv x86_64-1.0.0-alpha 91792014b61f 7 days ago 1.29 GB

现在运行完整脚本：

./network_setup.sh up

如果没有设置channel-ID参数，channel名默认是mychannel。脚本执行成功后输出：

===================== Query on PEER3 on channel 'mychannel' is successful =====================

===================== All GOOD, End-2-End execution completed =====================

此时，网络启动运行并测试成功。

清理¶

停止网络：

# 在e2e_cli目录下

docker rm -f $(docker ps -aq)

然后执行docker images命令查看Chaincode镜像，类似输出如下：

REPOSITORY TAG IMAGE ID CREATED SIZE

dev-peer3-mycc-1.0 latest 13f6c8b042c6 5 minutes ago 176 MB

dev-peer0-mycc-1.0 latest e27456b2bd92 5 minutes ago 176 MB

dev-peer2-mycc-1.0 latest 111098a7c98c 5 minutes ago 176 MB

删除这些镜像：

docker rmi

例如：

docker rmi -f 13f e27 111

最后删除配置结果，在crypto/orderer目录删除orderer.block和channel.tx。

configtxgen¶

configtxgen工具生成两个内容： Orderer的bootstrap block和Fabric的channel configuration transaction。

orderer block是ordering服务的创世区块；channel transaction文件在create channel时会被广播给orderer。

configtx.yaml包含网络的定义，并给出了网络组件的拓扑结构–2个成员（Org0和Org1）分别管理维护2个peer。还指出每个网络实体的加密材料的存储位置。crypto目录包含每个实体的admin证书、ca证书、签名证书和私钥。

为了方便使用，我们提供了一个脚本generateCfgTrx.sh，该脚本整合了configtxgen的执行过程，执行后会生成两个配置结果：orderer.block和channel.tx。如果你运行过上边的network_setup.sh则这两个配置结果已生成，要先到crypto/orderer目录将之删除。

执行generateCfgTrx.sh脚本¶

在e2e_cli目录下：

cd $GOPATH/src/github.com/hyperledger/fabric/examples/e2e_cli

generateCfgTrx.sh脚本有个可选参数channel-ID，如果不设此参数，则默认为mychannel。

# 如上所述，参数是可选的

./generateCfgTrx.sh

执行成功后输出：

2017/02/28 17:01:52 Generating new channel configtx

2017/02/28 17:01:52 Creating no-op MSP instance

2017/02/28 17:01:52 Obtaining default signing identity

2017/02/28 17:01:52 Creating no-op signing identity instance

2017/02/28 17:01:52 Serializing identity

2017/02/28 17:01:52 signing message

2017/02/28 17:01:52 Writing new channel tx

生成的orderer.block和channel.tx两个文件存放在crypto/orderer目录。

orderer.block是ordering服务的创世区块，channel.tx包含新channel的配置信息。如前所述，这俩文件都来自configtx.yaml及其所包含的加密材料和网络信息的数据。

注意：也可手动执行脚本generateCfgTrx.sh里的命令。如果使用这种方式，则必须先用e2e_cli目录下的configtx.yaml替换Fabric sampleconfig目录下默认的configtx.yaml，然后返回fabric目录执行这些命令，前提是删除之前generateCfgTrx.sh生成的两个文件。

启动网络¶

使用docker-compose启动网络，如果没有拉取Fabric镜像，则返回之前的操作去拉取镜像。

脚本script.sh嵌入到docker-compose文件里，该脚本将peer加入到channel并向peer发送read/write请求，如此便可自动执行交易流程。如果不想使用这个脚本自动执行交易，可以跳到下面“手动执行交易”一节。

在e2e_cli目录下使用docker-compose生成网络实体并执行嵌入的脚本：

CHANNEL_NAME= docker-compose up -d

如果之前创建了一个channel名，就必须将其作为参数，否则使用默认的mychannel。例如：

CHANNEL_NAME=mychannel docker-compose up -d

等待一会儿，因为背后有交易会发送到peer。执行docker ps查看运行状态的container，可以看到如下内容：

vagrant@hyperledger-devenv:v0.3.0-4eec836:/opt/gopath/src/github.com/hyperledger/fabric/examples/e2e_cli$ docker ps

CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES

45e3e114f7a2 dev-peer3-mycc-1.0 "chaincode -peer.a..." 4 seconds ago Up 4 seconds dev-peer3-mycc-1.0

5970f740ad2b dev-peer0-mycc-1.0 "chaincode -peer.a..." 24 seconds ago Up 23 seconds dev-peer0-mycc-1.0

b84808d66e99 dev-peer2-mycc-1.0 "chaincode -peer.a..." 48 seconds ago Up 47 seconds dev-peer2-mycc-1.0

16d7d94c8773 hyperledger/fabric-peer "peer node start -..." About a minute ago Up About a minute 0.0.0.0:10051->7051/tcp, 0.0.0.0:10053->7053/tcp peer3

3561a99e35e6 hyperledger/fabric-peer "peer node start -..." About a minute ago Up About a minute 0.0.0.0:9051->7051/tcp, 0.0.0.0:9053->7053/tcp peer2

0baad3047d92 hyperledger/fabric-peer "peer node start -..." About a minute ago Up About a minute 0.0.0.0:8051->7051/tcp, 0.0.0.0:8053->7053/tcp peer1

1216896b7b4f hyperledger/fabric-peer "peer node start -..." About a minute ago Up About a minute 0.0.0.0:7051->7051/tcp, 0.0.0.0:7053->7053/tcp peer0

155ff8747b4d hyperledger/fabric-orderer "orderer" About a minute ago Up About a minute 0.0.0.0:7050->7050/tcp orderer

背后发生了什么？¶

在CLI容器中执行了脚本script.sh。该脚本用默认的mychannel执行createChannel命令，这个命令用到了之前configtxgen工具生成的channel.tx。

createChannel执行后会生成一个创世区块mychannel.block并保存到当前目录。

对4个peer分别执行joinChannel命令，通过初始区块mychannel.block加入channel。至此，有一个channel包含4个peer和2个organization。

PEER0和PEER1属于Org0，PEER2和PEER3属于Org1。这些关系的定义都在configtx.yaml中

Chaincode chaincode_example02被install到PEER0和PEER2

然后Chaincode在PEER2上instantiate。实例化是指启动容器和初始化与Chaincode相关的键值对，本例中的初始值是[“a”,”100” “b”,”200”]。实例化的结果是一个名为dev-peer2-mycc-1.0的容器启动，注意，这个容器仅是针对PEER2。（译注：尤其注意这里仅仅是启动了一个container）

实例化时还会带有背书策略参数，本例中背书策略为`-P “OR (‘Org0MSP.member’,’Org1MSP.member’)”，意思是任何交易必须由绑定到Org0或者Org1的peer背书。

对于“a”的query请求发送到PEER0。在之前Chaincode被install到PEER0了，所以就可以启动一个名为dev-peer0-mycc-1.0的新容器，然后返回查询结果。由于没有write操作发生，所以“a”的值依然是“100”。

从“a“转移”10“给”b”的invoke请求发送到PEER0

Chaincode install到PEER3

对“a”的query请求发送到PEER3。这启动了第三个名为dev-peer3-mycc-1.0的容器，并返回查询结果90，正确的反映了之前的交易。

这表明了什么？¶

Chaincode必须被install到一个peer上才能成功的对这个peer的ledger执行read/write操作。此外，只有当在peer上针对chaincode执行read/write操作时，这个peer上才会启动该chaincode 容器。（比如，查询“a”的值）交易导致容器启动。channel中的所有peer（包括那些没有install chaincode的peer，就像上例中的PEER3）都会维护一个准确的ledger，ledger包含存储了不可变的、有序的交易记录的block，还有维护current state的statedb。在peer上install chaincode之后就可以直接使用该peer上的chaincode了（就像上例中的PEER3），因为之前已经instantiate过了（译注：即同一channel中的chaincode只需一次instantiate）。

查看交易¶

查看CLI容器的log：

docker logs -f cli

输出：

2017-02-28 04:31:20.841 UTC [logging] InitFromViper -> DEBU 001 Setting default logging level to DEBUG for command 'chaincode'

2017-02-28 04:31:20.842 UTC [msp] GetLocalMSP -> DEBU 002 Returning existing local MSP

2017-02-28 04:31:20.842 UTC [msp] GetDefaultSigningIdentity -> DEBU 003 Obtaining default signing identity

2017-02-28 04:31:20.843 UTC [msp] Sign -> DEBU 004 Sign: plaintext: 0A8F050A59080322096D796368616E6E...6D7963631A0A0A0571756572790A0161

2017-02-28 04:31:20.843 UTC [msp] Sign -> DEBU 005 Sign: digest: 52F1A41B7B0B08CF3FC94D9D7E916AC4C01C54399E71BC81D551B97F5619AB54

Query Result: 90

2017-02-28 04:31:30.425 UTC [main] main -> INFO 006 Exiting.....

===================== Query on chaincode on PEER3 on channel 'mychannel' is successful =====================

===================== All GOOD, End-2-End execution completed =====================

你也可以实时查看日志，需要打开两个终端。

首先，停止运行着的docker容器：

docker rm -f $(docker ps -aq)

在第一个终端启动docker-compose脚本：

# add the appropriate CHANNEL_NAME parm

CHANNEL_NAME= docker-compose up -d

在第二个终端查看log：

docker logs -f cli

这将实时输出通过script.sh执行的交易信息。

查看chaincode日志¶

对每个chaincode容器单独查看log，输出：

$ docker logs dev-peer2-mycc-1.0

04:30:45.947 [BCCSP_FACTORY] DEBU : Initialize BCCSP [SW]

ex02 Init

Aval = 100, Bval = 200

$ docker logs dev-peer0-mycc-1.0

04:31:10.569 [BCCSP_FACTORY] DEBU : Initialize BCCSP [SW]

ex02 Invoke

Query Response:{"Name":"a","Amount":"100"}

ex02 Invoke

Aval = 90, Bval = 210

$ docker logs dev-peer3-mycc-1.0

04:31:30.420 [BCCSP_FACTORY] DEBU : Initialize BCCSP [SW]

ex02 Invoke

Query Response:{"Name":"a","Amount":"90"}

手动执行交易¶

停止所有容器：

docker rm -f $(docker ps -aq)

然后，执行docker images命令查看chaincode镜像，会有类似以下内容：

REPOSITORY TAG IMAGE ID CREATED SIZE

dev-peer3-mycc-1.0 latest 13f6c8b042c6 5 minutes ago 176 MB

dev-peer0-mycc-1.0 latest e27456b2bd92 5 minutes ago 176 MB

dev-peer2-mycc-1.0 latest 111098a7c98c 5 minutes ago 176 MB

删除这些镜像：

docker rmi

比如：

docker rmi -f 13f e27 111

确保之前生成的配置内容还在，如果删除了就再执行脚本：

./generateCfgTrx.sh

或者使用脚本中的命令手动生成。

修改docker-compose文件¶

打开docker-compose文件注释掉执行script.sh脚本的命令，如下：

working_dir: /opt/gopath/src/github.com/hyperledger/fabric/peer

# command: /bin/bash -c './scripts/script.sh ${CHANNEL_NAME}'

保存文件，重启网络：

# 在e2e_cli目录下执行，设置正确的CHANNEL_NAME

CHANNEL_NAME= docker-compose up -d

命令语法¶

参照script.sh脚本中的create和join命令。下面的命令只是针对PEER0的，当对orderer和peer执行命令时，需要修改下面给出的四个环境变量的值。

# 对PEER0所用的环境变量

CORE_PEER_MSPCONFIGPATH=$GOPATH/src/github.com/hyperledger/fabric/peer/crypto/peer/peer0/localMspConfig

CORE_PEER_ADDRESS=peer0:7051

CORE_PEER_LOCALMSPID="Org0MSP"

CORE_PEER_TLS_ROOTCERT_FILE=$GOPATH/src/github.com/hyperledger/fabric/peer/crypto/peer/ peer0/localMspConfig/cacerts/peerOrg0.pem

每个peer的环境变量的值都在docker-compose文件中

Create channel¶

进去cli容器：

docker exec -it cli bash

执行成功输出：

root@0d78bb69300d:/opt/gopath/src/github.com/hyperledger/fabric/peer#

用-c指定channel name，-f指定channel configuration transaction（此例中是channel.tx），当然也可以使用不同的名称安装 configuration transaction。

# channel.tx 和 orderer.block 在 cli 容器的 crypto/orderer 目录下

peer channel create -o orderer0:7050 -c mychannel -f crypto/orderer/channel.tx --tls $CORE_PEER_TLS_ENABLED --cafile $GOPATH/src/github.com/hyperledger/fabric/peer/crypto/orderer/localMspConfig/cacerts/ordererOrg0.pem

由于此例的peer channel create命令是针对orderer的，所以需要修改之前的环境变量，因此上边的命令应该是：

CORE_PEER_MSPCONFIGPATH=$GOPATH/src/github.com/hyperledger/fabric/peer/crypto/orderer/localMspConfig CORE_PEER_LOCALMSPID="OrdererMSP" peer channel create -o orderer0:7050 -c mychannel -f crypto/orderer/channel.tx --tls $CORE_PEER_TLS_ENABLED --cafile $GOPATH/src/github.com/hyperledger/fabric/peer/crypto/orderer/localMspConfig/cacerts/ordererOrg0.pem

注意：下面的其他命令依然在CLI容器中执行，而且要记住命令里每个peer对应的环境变量

Join channel¶

将指定的peer加入到channel：

# 默认只将 PEER0 加入

peer channel join -b mychannel.block

完整的命令应该是：

CORE_PEER_MSPCONFIGPATH=$GOPATH/src/github.com/hyperledger/fabric/peer/crypto/peer/peer0/localMspConfig CORE_PEER_ADDRESS=peer0:7051 CORE_PEER_LOCALMSPID="Org0MSP" CORE_PEER_TLS_ROOTCERT_FILE=$GOPATH/src/github.com/hyperledger/fabric/peer/crypto/peer/peer0/localMspConfig/cacerts/peerOrg0.pem peer channel join -b mychannel.block

修改这四个环境变量将其他的peer加入到channel中

Install chaincode¶

将示例chaincode代码安装到四个对等节点中的一个：

# 在命令前面要加上peer对应的四个环境变量

peer chaincode install -n mycc -v 1.0 -p github.com/hyperledger/fabric/examples/chaincode/go/chaincode_example02

Instantiate chaincode¶

在一个peer上实例化chaincode，这将对该peer启动一个chaincode容器，并为该chaincode设置背书策略。此例中定义的策略是有Org0或Org1中的一个peer背书即可。命令如下：

# 在命令前面要加上peer对应的四个环境变量

# 用 -C 参数设置正确的channel名，默认是 mychannel

peer chaincode instantiate -o orderer0:7050 --tls $CORE_PEER_TLS_ENABLED --cafile $GOPATH/src/github.com/hyperledger/fabric/peer/crypto/orderer/localMspConfig/cacerts/ordererOrg0.pem -C mychannel -n mycc -v 1.0 -p github.com/hyperledger/fabric/examples/chaincode/go/chaincode_example02 -c '{"Args":["init","a", "100", "b","200"]}' -P "OR ('Org0MSP.member','Org1MSP.member')"

Invoke chaincode¶

# 在命令前面要加上peer对应的四个环境变量

peer chaincode invoke -o orderer0:7050 --tls $CORE_PEER_TLS_ENABLED --cafile $GOPATH/src/github.com/hyperledger/fabric/peer/crypto/orderer/localMspConfig/cacerts/ordererOrg0.pem -C mychannel -n mycc -c '{"Args":["invoke","a","b","10"]}'

Query chaincode¶

# 在命令前面要加上peer对应的四个环境变量

peer chaincode query -C mychannel -n mycc -c '{"Args":["query","a"]}'

执行结果：

Query Result: 90

手动构建镜像¶

构建peer和orderer镜像：

# 在fabric目录下执行，如果不能顺利生成镜像，则使用vagrant环境

make peer-docker orderer-docker

执行docker images命令输出：

vagrant@hyperledger-devenv:v0.3.0-4eec836:/opt/gopath/src/github.com/hyperledger/fabric$ docker images

REPOSITORY TAG IMAGE ID CREATED SIZE

hyperledger/fabric-orderer latest 264e45897bfb 10 minutes ago 180 MB

hyperledger/fabric-orderer x86_64-0.7.0-snapshot-a0d032b 264e45897bfb 10 minutes ago 180 MB

hyperledger/fabric-peer latest b3d44cff07c6 10 minutes ago 184 MB

hyperledger/fabric-peer x86_64-0.7.0-snapshot-a0d032b b3d44cff07c6 10 minutes ago 184 MB

hyperledger/fabric-javaenv latest 6e2a2adb998a 10 minutes ago 1.42 GB

hyperledger/fabric-javaenv x86_64-0.7.0-snapshot-a0d032b 6e2a2adb998a 10 minutes ago 1.42 GB

hyperledger/fabric-ccenv latest 0ce0e7dc043f 12 minutes ago 1.29 GB

hyperledger/fabric-ccenv x86_64-0.7.0-snapshot-a0d032b 0ce0e7dc043f 12 minutes ago 1.29 GB

hyperledger/fabric-baseimage x86_64-0.3.0 f4751a503f02 4 weeks ago 1.27 GB

hyperledger/fabric-baseos x86_64-0.3.0 c3a4cf3b3350 4 weeks ago 161 MB

使用本地二进制文件¶

进去vagrant环境：

cd $GOPATH/src/github.com/hyperledger/fabric/devenv

# 第一次启动VM用 vagrant up

vagrant ssh

在fabric目录下编译peer和orderer：

make clean

make native

生成ccenv镜像：

make peer-docker

然后打开两个终端都进入vagrant，至此有三个终端都在vagrant里。

前首先清空ledger文件夹/var/hyperledger/（每次运行后，为避免错误或重复，都要清空）:

rm -rf /var/hyperledger/*

终端1¶

使用configtxgen工具创建orderer创世区块：

configtxgen -profile SampleSingleMSPSolo -outputBlock orderer.block

终端2¶

用刚生成的创世区块启动orderer：

ORDERER_GENERAL_GENESISMETHOD=file ORDERER_GENERAL_GENESISFILE=./orderer.block orderer

终端1¶

创建 channel configuration transaction：

configtxgen -profile SampleSingleMSPSolo -outputCreateChannelTx channel.tx -channelID

执行成功会在当前目录生成channel.tx

终端3¶

以chainless模式启动peer：

peer node start --peer-defaultchain=false

Create channel¶

以channel.tx为参数创建channel：

peer channel create -o 127.0.0.1:7050 -c mychannel -f channel.tx

执行后在当前目录生成一个channel的创世区块mychannel.block

Join channel¶

通过channel的创世区块mychannel.block加入channel：

peer channel join -b mychannel.block

Install chaincode¶

在peer上安装chaincode：

peer chaincode install -o 127.0.0.1:7050 -n mycc -v 1.0 -p github.com/hyperledger/fabric/examples/chaincode/go/chaincode_example02

执行成功后查看文件可以看到mycc.1.0:

ls /var/hyperledger/production/chaincodes

Instantiate chaincode¶

实例化chaincode：

peer chaincode instantiate -o 127.0.0.1:7050 -C mychannel -n mycc -v 1.0 -p github.com/hyperledger/fabric/examples/chaincode/go/chaincode_example02 -c '{"Args":["init","a", "100", "b","200"]}'

docker ps查看运行中的容器，如果chaincode启动成功，则显示：

CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES

bd9c6bda7560 dev-jdoe-mycc-1.0 "chaincode -peer.a..." 5 seconds ago Up 5 seconds dev-jdoe-mycc-1.0

Invoke chaincode¶

调用chaincode从“a”转移“10”给“b“：

peer chaincode invoke -o 127.0.0.1:7050 -C mychannel -n mycc -c '{"Args":["invoke","a","b","10"]}'

Query chaincode¶

查询”a“的值：

# 返回值应是 90

peer chaincode query -o 127.0.0.1:7050 -C mychannel -n mycc -c '{"Args":["query","a"]}'

运行完成后不要忘记清空ledger文件夹/var/hyperledger/：

rm -rf /var/hyperledger/*

使用CouchDB¶

可以将stateDB默认的goleveldb替换成CouchDB。对于CouchDB，chaincode各功能依然可用，但将chaincode数据以JSON方式存储的话就可使用CouchDB的复杂查询的功能。

为了使用CouchDB，除了最前面的”前提“一节的操作外，还需要下边两步启动CouchDB容器并将之与peer容器关联：

构建CouchDB镜像：

# make sure you are in the fabric directory

make couchdb

编辑fabric/examples/e2e_cli/docker-compose.yaml和docker-compose.yam，将所有与CouchDB有关的内容取消注释。这样chaincode_example02就可以才CouchDB下运行了。

注意：如果将CouchDB容器的端口映射的主机，请一定要注意安全。在开发环境中将端口映射出来可以通过CouchDB的web界面可视化操作数据。生产环境中一般不会做端口映射，以限制CouchDB的外部访问。

可以用chaincode_example02在CouchDB下执行上边的chaincode操作，但是为了使用CouchDB的复杂查询功能，chaincode数据一定要以JSON格式存储（例如fabric/examples/chaincode/go/marbles02）。

使用手动执行交易这一节中的步骤install、instantiate、invoke和query marbles02，执行完Join channel这步后使用下边的命令操作marbles02：

在PEER0上安装并实例化chaincode

peer chaincode install -o orderer0:7050 -n marbles -v 1.0 -p github.com/hyperledger/fabric/examples/chaincode/go/marbles02

peer chaincode instantiate -o orderer0:7050 --tls $CORE_PEER_TLS_ENABLED --cafile /opt/gopath/src/github.com/hyperledger/fabric/peer/crypto/orderer/localMspConfig/cacerts/ordererOrg0.pem -C mychannel -n marbles -v 1.0 -p github.com/hyperledger/fabric/examples/chaincode/go/marbles02 -c '{"Args":["init"]}' -P "OR ('Org0MSP.member','Org1MSP.member')"

创建一些marble并移动它们

peer chaincode invoke -o orderer0:7050 --tls $CORE_PEER_TLS_ENABLED --cafile /opt/gopath/src/github.com/hyperledger/fabric/peer/crypto/orderer/localMspConfig/cacerts/ordererOrg0.pem -C mychannel -n marbles -c '{"Args":["initMarble","marble1","blue","35","tom"]}'

如果做了CouchDB容器的端口映射，可以通过web界面查看数据，可以看到名为mychannel的数据库及其文档

如果使用的是vagrant环境

http://localhost:15984/_utils

* 如果不是vagrant环境，使用CouchDB容器指定的端口

http://localhost:5984/_utils

可有规律的查询chaincode（例如，读取marble2）

peer chaincode query -C mychannel -n marbles -c ‘{“Args”:[“readMarble”,”marble2”]}’

可以看到marble2的详细信息：

Query Result: {"color":"red","docType":"marble","name":"marble2","owner":"jerry","size":50}

获取marble1的历史：

peer chaincode query -C mychannel -n marbles -c '{"Args":["getHistoryForMarble","marble1"]}'

可以看到操作过marble1的交易：

Query Result: [{"TxId":"1c3d3caf124c89f91a4c0f353723ac736c58155325f02890adebaa15e16e6464", "Value":{"docType":"marble","name":"marble1","color":"blue","size":35,"owner":"tom"}},{"TxId":"755d55c281889eaeebf405586f9e25d71d36eb3d35420af833a20a2f53a3eefd", "Value":{"docType":"marble","name":"marble1","color":"blue","size":35,"owner":"jerry"}},{"TxId":"819451032d813dde6247f85e56a89262555e04f14788ee33e28b232eef36d98f", "Value":}]

还可以执行复杂查询，比如查询jerry所拥有的marble：

peer chaincode query -C mychannel -n marbles -c '{"Args":["queryMarblesByOwner","jerry"]}'

查询结果为jerry所拥有的2个marble的信息：

Query Result: [{"Key":"marble2", "Record":{"color":"red","docType":"marble","name":"marble2","owner":"jerry","size":50}},{"Key":"marble3", "Record":{"color":"blue","docType":"marble","name":"marble3","owner":"jerry","size":70}}]

通过owner字段等于jerry查询：

peer chaincode query -C mychannel -n marbles -c '{"Args":["queryMarbles","{\"selector\":{\"owner\":\"jerry\"}}"]}'

查询结果如下：

数据持久化¶

如果需要对peer或CouchDB容器的数据持久化，一种选择是将容器的相关目录挂在到docker主机。例如，将下面两行内容放到docker-compose.yaml文件中的对应peer处：

volumes:

- /var/hyperledger/peer0:/var/hyperledger/production

将下面两行放到对应的CouchDB处：

volumes:

- /var/hyperledger/couchdb0:/opt/couchdb/data

故障排出¶

每次运行后要清理文件

如果出现docker错误，则删除镜像，从头再操作一遍

make clean

make peer-docker orderer-docker

如果出现下面的错误

Error: Error endorsing chaincode: rpc error: code = 2 desc = Error installing chaincode code mycc:1.0(chaincode /var/hyperledger/production/chaincodes/mycc.1.0 exits)

chaincode镜像（如dev-peer0-mycc-1.0或dev-peer1-mycc-1.0）可能是以前运行过的。删除它们然后重试。

docker rmi -f $(docker images | grep peer[0-9]-peer[0-9] | awk '{print $3}')

使用down选项清理网络

./network_setup.sh down

Next Previous

Hyperledger国际化工作组(yls@chainnova.com)

Built with MkDocs using a theme provided by Read the Docs.

GitHub

« Previous

Fabric 介绍 — Hyperledger Fabric 中文文档文档

Hyperledger Fabric 中文文档

latest

Contents:

核心概念

Fabric 介绍

什么是区块链？

为什么区块链有用？

什么是 Hyperledger Fabric?

我在哪里可以学到更多？

Hyperledger Fabric 功能

Hyperledger Fabric Model

身份系统 Identity

成员关系

Peers

账本

Hyperledger Fabric 中文文档

Docs »

核心概念 »

Fabric 介绍

Edit on GitHub

Fabric 介绍¶

Hyperledger Fabric 是一个模块化架构的分布式账本平台，提供高度的机密性，弹性，灵活性和可扩展性。它旨在支持不同组件的可插拔实现，并且可以容纳生态系统中存在的高度复杂应用。

与别的区块链解决方案不同的是，Hyperledger Fabric 提供了独一无二的可伸缩架构。它也是为了满足未来需要审核的企业级区块链需求，从而在此基础上建立的开源架构。Hyperledger Fabric 将是你的起点。

我们建议首次使用的用户先阅读下面的介绍，以便熟悉区块链的工作方式以及 Hyperledger Fabric 的特定功能和组件。

一旦你感觉良好之后 — 或者说你已经熟悉了区块链以及 Hyperledger Fabric，那就跳到 Getting Started 章节，在那里探索更多的样例，技术规范，以及API等等。

什么是区块链？¶

分布式账本（A Distributed Ledger）

区块链网络的核心是一个分布式账本，用于记录在网络上发生的所有交易。区块链账本通常被描述为去中心化的，因为它被复制到许多网络参与者中，每个参与者都在协作维护。我们将看到，分权和协作是反映企业在现实世界中交换产品和服务方式的强大属性。

除了去中心化和协作之外，记录在区块链中的信息只能追加，使用加密技术可保证一旦交易添加在账本中，便无法对其进行修改。这种无法篡改的特性使得判断信息的来源变得很简单，因为参与者可以肯定信息在事后没有被改变。这就是区块链有时被描述为证明体系的原因。

智能合约（Smart Contracts）

为了支持信息一致性更新 —— 启用一整作用于账本的功能（交易，查询等） —— 区块链网络使用智能合约来提供对账本访问控制。

智能合约不仅是简单的封装信息在整个网络中同步，它们也可以被写入以允许参与者的一些交易能自动执行。例如，可以写一份智能合约，通过物品何时到达来决定传输费用。双方一旦同意该条款并写入账本中，当商品到达时，相应的资金将会自动被转入。

共识（Consensus）

通过网络保持分类账交易同步的过程 — 确保账本只有在交易获得相应的参与者批准时才更新，并且当账本更新时，它们以包含相同的顺序区块来更新账本 — 这个过程就称为共识。

我们将在后面学习更多关于账本、智能合约和共识的知识。就目前而言，将区块链视为共享的、复制的交易系统就足够了，该交易系统通过智能合约进行更新，并通过称为共识的协作过程保持一致同步。

为什么区块链有用？¶

现有的记录系统

今天的交易网络仅仅是对老旧的商业记录保存进行简单的更新。一个商业网络的成员彼此进行交易，但他们各自都维护着一套交易记录 — 无论是16世纪的佛兰芒挂毯还是今天的证券 — 每次出售时都必须确立其出处，以确保出售商品的商家拥有一系列产权。

它看起来像这样的商业网络：

现代技术已经从石板和纸质文件夹的时代过渡到硬盘驱动和云平台了，但是其底层架构是相同的。用于管理网络参与者身份的统一系统不存在，建立起源非常费力，需要数天的时间才能清除证券交易（世界量级是数万亿美元），合同必须手动签名和执行，并且系统中的每个数据库都包含唯一信息，因此意味着单点故障的发生。

交易对可见性和信任体系的需求是明确的，但今天的信息和流程分享方法仍然不可能建立跨越商业网络的记录系统。

区块链的与众不同之处

如果，相对于现在这种低效的交易系统，提供了一种标准体系来建立身份网络、交易自动执行、和数据同步存储会怎样？如果通过查看交易清单，一旦写入就不允许更改，以此来建立资产来源机制会如何？是不是这样，就能够形成信任体系呢？

上图描述了一个区块链网络，每个参与者都有自己的账本副本。除了共享账本信息之外，账本更新的过程也是共享的。

与今天的系统不同，今天的系统是私人的程序用来更新私人的账本，而区块链系统则是通过共享程序来更新共享的账本。

凭借通过共享账本协调业务网络的能力，区块链网络可以减少与私人信息处理时间、成本和风险，同时提高相互信任度和信息透明度。

您现在知道区块链是什么以及它为什么有用。区块链还有很多其他重要的细节，但都跟上面所提到的信息和流程共享的基本思想分不开。

什么是 Hyperledger Fabric?¶

Linux 基金会于2015年创立了 Hyperledger，以推进跨行业区块链技术。相对于声明一个的区块链标准，它鼓励通过社区协作流程来开发区块链技术，鼓励开源来开发知识产权并最终采用一套标准。

Hyperledger Fabric 是 Hyperledger 中的区块链项目之一。像其他区块链技术一样，它具有账本，使用智能合约，并且系统是参与者管理其交易的。

Hyperledger Fabric从其他一些区块链系统中脱颖而出的地方在于它是私密的并且是权限化的。相对于允许未知身份参与网络的开放式权限系统（需要工作证明等协议来验证交易和保护网络）。Hyperledger Fabric 网络的成员通过注册可信成员服务提供商（Membership Service Provider 简称 MSP）来保证系统的私密性。

Hyperledger Fabric 还提供多种可热插拔选项。账本数据可以以多种格式来存储，共识机制可以随时切换开关，并支持多种的MSP。

Hyperledger Fabric 还提供了创建频道（channels）的能力，允许一组参与者创建单独的交易账本。对网络参与者中有潜在的竞争对手的情况下，这是一个特别重要的选择 — 例如，他们向某些参与者提供的特殊价格 — 每位参与者都知道。如果两个参与者都在一个频道，那么这些参与者（没有其他人）就拥有该频道的账本副本。

共享账本（Shared Ledger）

Hyperledger Fabric 的账本系统有两个组件：世界状态（world state）和事务日志（transaction log）。每个参与者都将分类帐的副本分配给所属的每个 Hyperledger Fabric 网络。Hyperledger Fabric 中的网络参与者都有一本账本副本。

世界状态组件描述了在特定时间点下账本的状态。这是相当于账本的数据库。交易日志组件记录了构成世界状态的所有交易;由此得出，账本是世界状态数据库和交易日志历史记录的组合。

账本对世界状态有可替换的数据存储。默认情况下，这是一个 LevelDB 键值存储数据库。事务日志不需要是可插拔的。它只记录区块链网络中使用的账本数据库的前后值。

智能合约（Smart Contracts）

Hyperledger Fabric 的智能合约是用 chaincode 实现的，并且被区块链外部应用程序所调用，以此来与账本交互。在大多数情况下，chaincode 仅与账本的数据库组件（世界状态）（例如查询）交互，而不与交易日志交互。

Chaincode 可以用几种编程语言实现。目前支持的 chaincode 的语言是 Go，未来将支持 Java 和其他语言。

私密性（Privacy）

根据网络的需求，企业对企业（B2B）网络的参与者可能对他们共享多少信息非常敏感。对于其他区块链网络而言，隐私不会成为首要问题。

相遇对其他的区块链网络，隐私（使用频道方法）对于 Hyperledger Fabric 是非常关键的要求。

共识（Consensus）

交易必须按照发生的顺序写入账本中，网络中不同的参与者皆是如此。要做到这点，必须建立交易顺序，并且必须实施一种方法，用于拒绝错误（或恶意）插入账本的不良交易。

这是一个老生常谈的计算机科学领域，有很多方法可以实现共识算法，每个方法都有不同的利弊。例如，PBFT（Practical Byzantine Fault Tolerance）可以提供文件副本相互通信的机制，以保持每个副本的一致性，即使在发生损坏的情况下。或者，在比特币中，通过计算加密问题（也被称为挖矿）来实现共识，谁先算出来该区块就算谁的。

Hyperledger Fabric 被设计为允许网络初始者选择最能代表参与者之间存在关系的共识机制。与隐私一样，还有一系列需求;从关系高度结构化的网络到更加点对点的网络。

我们将了解更多的 Hyperledger Fabric 共识机制，其中目前包括 SOLO，Kafka，并且在另一个文档中，会很快将了解到 SBFT（简化的拜占庭容错）。

我在哪里可以学到更多？¶

我们提供了许多教程，将在其中介绍区块链网络中的大多数关键组件，详细了解他们如何与彼此进行交互，然后您将了解相关代码并针对正在运行的区块链网络运行一些简单的交易。我们还为那些想使用 Hyperledger Fabric 来运行区块链网络的人提供教程。

深入了解本介绍中引入的组件的概念以及其他的几个概念，并描述了它们是如何在样本事务流中一起工作。

Revision 5580ae4b.

Built with Sphinx using a theme provided by Read the Docs.

Read the Docs

v: latest

Versions

latest

Downloads

pdf

htmlzip

epub

On Read the Docs

Project Home

Builds

Free document hosting provided by Read the Docs.

Hyperledger Fabric 小白入门指南 - 知乎

Hyperledger Fabric 小白入门指南 - 知乎首发于区块链系统切换模式写文章登录/注册Hyperledger Fabric 小白入门指南叶之秋zkp 学习中 ... 区块链本身是一个复杂的系统，是计算机不同领域技术的精妙组合，涉及密码学、P2P网络、分布式系统、数据库等大方向，且仍在不断地发展之中。目前，区块链领域有非常多亟待解决的问题，每年各种数据库、网络、系统、安全会议都会接收区块链相关的论文。具体到 Hyperledger Fabric 这个项目，又涉及一些具体实现上的技术选择，Fabric 本身又涉及非常多的概念。面对这种大型项目，初学者往往容易陷入琐碎的细节，而无法做到全局的把握，非常容易感到迷茫。我觉得最好的学习方式是带着问题去学习，不断地解决主线问题，先把框架搭起来，对 Fabric 有个整体的认识，学有余力可以去深入研究某个支线。结合我自己的学习经历，我这里列出一些个人认为比较重要的问题或者步骤，没什么基础的初学者可以按下面这个顺序学习，可以视个人情况调整顺序或者有选择的跳过。基础1. （了解基础的密码学知识：哈希、非对称加密、公钥基础设施）2. 理解 Fabric 的关键概念 - 什么是 peer、endorser、orderer？ - 什么时 anchor peer、leading peer？ - 什么是智能合约、链码？ - 什么是通道（channel）？ - 什么是 Execute-Order-Validation？与Order-Execute 有什么不同？各有什么好处？ - 初步了解一个 transaction 的生命周期：从 client 发起，到最终上链。3. （学习 Linux 的基本操作）4. （学习 Docker 即 Docker Composer 的使用）5. 在单机上使用现成的脚本搭建一个简单的区块链网络（比如经典的 BYFN，主要是为了验证环境配置成功）6. 去分步弄清楚第四步中部署的区块链网络是如何启动的7. 在区块链网络上部署一个智能合约，并进行简单测试进阶8. 去弄明白第四步启动网络时的参数，比如 - Dockerfile 文件里那些变量的意义 - 如何修改参数启动更多的 Org 和加入更多的 peer 9. 将 Solo 单节点共识替换成其它生产环境下使用的共识机制，比如 Raft 10. 了解 MSP：弄明白 Fabric 如何管理区块链网络中的身份 11. 了解背书策略（Endorsement Policy） 12. （了解 private collection ） 13. 了解 validation 阶段的 MVCC 做了什么，为什么会有 transaction 验证失败被标记为无效 14. 学习如何编写智能合约（即开发应用） 15. 学习如何多机器分布式部署（关键在于 Docker 网络配置） 16. 学习使用 Caliper 测试 Fabric 的性能，并尝试调整 Fabric 的核心参数观察性能的变化 17. 将 Raft 共识机制替换成拜占庭共识（比如 BFT-SMaRt）高阶到这里主要就是去学习源码去深入理解其中的细节了。这里其实并**不分**先后顺序，相信到这一步的同学也都知道自己想要学什么了。我就简单列几点： 18. 学习 cryptogen 这个工具，知道 Fabric 里的CA系统是如何工作的19. 学习 Fabric 是如何注册、部署、启动链码的，链码容器如何与peer交互的20. 学习 MSP 和 Endorsement Policy 是如何工作的21. 学习 Gossip 模块 22. 学习 VSCC 是如何工作的23. 学习如何进行冲突检测的，即 MVCC 模块是如何工作的24. 学习底层存储机制： - block 和 world state 是如何存储的？ - 多通道的数据底层是如何隔离的？ - 不同链码访问数据结构底层是如何隔离的？我这里并不打算推荐具体的学习资料。网上有非常多的相关博客了，书籍也有一些，学习初期可以多看看，不同的信息来源也可以互相补充、互相印证。如果非要推荐的话，那就去读官方文档吧，毕竟没有人比他们更了解 Fabric。~~唯一的缺点就是文档太长了~~。回想起大二下的时候，机缘巧合加入了某个老师的区块链项目，那是我第一次接触区块链和 Fabric，也是第一次去阅读英文文档。后来，在对区块链的迷茫中，转行跟着另一位老师搞了一年 AI。再后来又阴差阳错回到了区块链这个领域，学习 Fabric、Bitcoin、Ethereum，学习共识算法，学习数据库，感觉还挺有意思。目前仍在不断摸索中，欢迎交流：）发布于 2021-06-30 23:24分布式系统区块链(Blockchain)Hyperledger赞同 8821 条评论分享喜欢收藏申请转载文章被以下专栏收录区块链系统关于主流区块链平台

编写一个 Fabric 应用 — hyperledger-fabricdocs master 文档

hyperledger-fabricdocs

latest

我们是谁

介绍

Hyperledger Fabric v2.0 更新说明

发行说明

关键概念

入门

开发应用

教程

使用Fabric的测试网络

将智能合约部署到通道

编写一个 Fabric 应用

开始之前

设置区块链网络

启动区块链网络

部署智能合约

准备样例应用

运行样例应用

首先,建立与Gateway的gRPC连接

其次,创建Gateway连接

第三，访问要调用的智能合约

第五，调用事务函数以读取和写入资产

清理

总结

商业票据教程

在 Fabric 中使用私有数据

使用 CouchDB

创建通道

向通道添加组织

更新通道配置

链码开发者教程

视频

部署一个生产网络

操作指南

升级到最新版本

命令参考

架构参考

常见问题

欢迎贡献！

术语表

版本发布

仍有问题？

状态

hyperledger-fabricdocs

教程

编写一个 Fabric 应用

Edit on GitHub

编写一个 Fabric 应用¶

注解

如果你对 Fabric 网络的基本架构还不熟悉，在继续本部分之前，你可能想先阅读关键概念部分。

本你还应该熟悉Fabric Gateway服务以及它与应用程序交易流程的关系,详细信息可以在 :doc:’gateway’ 章节。

本教程介绍了Fabric应用程序与已部署区块链网络的交互方式。本教程使用使用Fabric Gateway客户端API构建的示例程序来调用智能合约,

使用智能合约API查询和更新账本, 详细信息在 :doc:’deploy_chaincode’.

关于资产转移

资产转移(基本）样例展示了如何创建，更新和查询资产。它包括下面两个组件：

1. 示例应用程序调用区块链网络，调用智能合约中实现的交易。这个应用位于 ‘fabric-samples’目录里：

.. code-block:: text

asset-transfer-basic/application-gateway-typescript

智能合约: 实现了涉及与账本交互的交易。智能合约位于下面’’fabric-samples’’目录里：

asset-transfer-basic/chaincode-(typescript, go, java)

在这个例子里，我们将用 TypeScript 智能合约。

本教程包含两个重要部分：

1. 搭建链块网络.

我们的应用程序需要和区块链网络交互，所以我们启动基础网络和部署一个智能合约给我们的应用程序使用。

2. 运行实例和智能合约互动.

我们的应用将使用assetTransfer智能合约在账本上创建、查询和更新资产。我们将逐步分析应用程序的代码以及它所调用的交易,

包括创建一些初始资产、查询一个资产、查询一系列资产、创建新资产以及将资产转让给新所有者。

完成本教程后,您应该对Fabric应用程序和智能合约如何协同工作来管理区块链网络的分布式账本数据有基本的理解.

开始之前¶

在你能运行样例应用前，你需要在你的环境里安装 Fabric Sampple. 根据 :doc:’getting_started’ 的指令安装必要的软件。

本教程中的样例应用在节点上使用了 Fabric Gateway client API。要获取最新支持的编程语言运行时和依赖项的列表,

请参考文档。

请确保已安装适当版本的Node。有关安装Node的说明,请参 Node.js 文档.

设置区块链网络¶

如果你已经学习了使用Fabric的测试网络而且已经运行起来了一个网络，本教程将在启动一个新网络之前关闭正在运行的网络。

启动区块链网络¶

在你本地 ‘’fabric-samples’’代码库的本地拷贝里，导航到 ‘’test-network’’子目录。

cd fabric-samples/test-network

如果你已经有个测试网络可以运行，请将它关闭以确保环境是干净的。

./network.sh up createChannel -c mychannel -ca

该命令将部署具有两个对等方、一个排序服务和三个证书颁发机构(Orderer、Org1、Org2) 的Fabric测试网络。

与使用cryptogen工具不同.我们使用证书颁发机构来启动测试网络，因此使用了‘-ca’标志。此外，

在启动证书颁发机构时还会初始化组织管理员用户的注册。

部署智能合约¶

注解

本教程演示了Asset Transfer智能合约和应用程序的TypeScript版本,

但您可以将TypeScript应用程序示例与任何智能合约语言示例一起使用

(例如TypeScript应用程序调用Go智能合约函数或TypeScript应用程序调用Java智能合约函数等)。

要尝试Go或Java版本的智能合约,请将下面的’’./network.sh deployCC -ccl typescript’’命令中的

‘’typescript’’参数更改为’’go’’或’’java’’,然后按照终端上的说明进行操作。

接下来，让我们通过调用’’./network.sh’’ 脚本并提供链码名称和语言选项来部署包含智能合约的链码包。

./network.sh deployCC -ccn basic -ccp ../asset-transfer-basic/chaincode-typescript/ -ccl typescript

此脚本使用链码生命周期来打包、安装、查询已安装的链码、为Org1和Org2批准链码,最后提交链码。

如果链码包成功部署，终端输出的末尾应该类似于以下内容：

Committed chaincode definition for chaincode 'basic' on channel 'mychannel':

Version: 1.0, Sequence: 1, Endorsement Plugin: escc, Validation Plugin: vscc, Approvals: [Org1MSP: true, Org2MSP: true]

Query chaincode definition successful on peer0.org2 on channel 'mychannel'

Chaincode initialization is not required

准备样例应用¶

现在,让我们准备样本的Asset Transfer ‘TypeScript 应用程序’_ ,

该应用程序将用于与已部署的智能合约进行交互。

打开一个新的终端，然后导航到’’application-gateway-typescript’’目录。

cd asset-transfer-basic/application-gateway-typescript

该目录包含一个使用Fabric Gateway客户端API for Node开发的示例应用程序。

运行以下命令来安装依赖并构建应用程序。这可能需要一些时间来完成：

npm install

这个过程会安装应用程序在’’package.json’’中定义的依赖项。其中最重要的是’’@hyperledger/fabric-gateway’’’ Node.js包,

它提供了用于连接到Fabric Gateway并使用特定客户身份提交和评估事务以及接收事件的Fabric Gateway客户端API。

一旦完成 npm install ，运行应用程序所需要的一切就准备好了。

让我们来看一眼教程中使用的示例 TypeScript 应用文件。运行下面命令，列出所以在此目录的文件：

你会看到下边的文件：

dist

node_modules

package-lock.json

package.json

src

tsconfig.json

‘’src’’目录包含客户端应用程序的源代码。在安装过程中从这些源代码生成的JavaScript输出位于’’dist’’目录中，可以忽略。

运行样例应用¶

在本教程的前面部分,我们启动了Fabric测试网络,使用证书颁发机构创建了几个身份。其中包括每个组织的用户身份。

应用程序将使用这些用户身份中的一个来与区块链网络交互。

让我们运行该应用程序,然后逐步了解与智能合约函数的每次交互。

从’’asset-transfer-basic/application-gateway-typescript’’目录,运行以下命令:

npm start

首先,建立与Gateway的gRPC连接¶

客户端应用程序建立了与将用于与区块链网络交互的Fabric Gateway服务的’gRPC ’_连接。

为此,它只需要Fabric Gateway的终端地址,以及如果配置为使用TLS,则需要适当的TLS证书。

在这个示例中,网关终端地址是对等方的地址,它提供了Fabric Gateway服务。

注解

建立gRPC连接涉及到相当大的开销,因此应用程序应该保留这个连接,并用它来进行与Fabric Gateway的所有交互。

警告

为了保护交易中使用的任何私有数据的安全,应用程序应连接到与客户身份所属组织相同的Fabric Gateway。

如果客户身份所属的组织不托管任何网关,则应使用另一个组织的受信任网关。

TypeScript应用程序使用签名证书颁发机构的TLS证书来创建gRPC连接,以便验证网关的TLS证书的真实性。

为了成功建立TLS连接,客户端使用的终端地址必须与网关的TLS证书中的地址匹配。由于客户端访问网关的Docker容器时使用的是’localhost’地址,

因此需要指定一个gRPC选项,强制将此终端地址解释为网关的配置主机名。

const peerEndpoint = 'localhost:7051';

async function newGrpcConnection(): Promise {

const tlsRootCert = await fs.readFile(tlsCertPath);

const tlsCredentials = grpc.credentials.createSsl(tlsRootCert);

return new grpc.Client(peerEndpoint, tlsCredentials, {

'grpc.ssl_target_name_override': 'peer0.org1.example.com',

});

}

其次,创建Gateway连接¶

然后,应用程序创建一个’’Gateway’’连接,用于访问Fabric Gateway可访问的任何’’Networks’’(类似于通道),

以及随后在这些网络上部署的智能’Contracts’。’’Gateway’’连接具有三个要求:

与Fabric Gateway的gRPC连接。

用于与网络交互的客户身份。

用于为客户身份生成数字签名的签名实现。

示例应用程序使用Org1用户的X.509证书作为客户身份，以及基于该用户的私钥的签名实现。

const client = await newGrpcConnection();

const gateway = connect({

client,

identity: await newIdentity(),

signer: await newSigner(),

});

async function newIdentity(): Promise {

const credentials = await fs.readFile(certPath);

return { mspId: 'Org1MSP', credentials };

}

async function newSigner(): Promise {

const privateKeyPem = await fs.readFile(keyPath);

const privateKey = crypto.createPrivateKey(privateKeyPem);

return signers.newPrivateKeySigner(privateKey);

}

第三，访问要调用的智能合约¶

示例应用程序使用’’Gateway’’连接获取对’’Network’’的引用,然后获取该网络上部署的默认’’Contract’’。

const network = gateway.getNetwork(channelName);

const contract = network.getContract(chaincodeName);

当一个链码包包括多个智能合约时,可以将链码的名称和特定智能合约的名称作为

‘getContract() `_的参数传递。

例如：

const contract = network.getContract(chaincodeName, smartContractName);

第四，使用样本资产填充账本

在初始部署链码包之后,账本是空的。应用程序使用’’submitTransaction()’’来调用’’InitLedger’’事务函数,

该函数将账本填充了一些样本资产。’’submitTransaction()’’将使用Fabric Gateway来执行以下操作:

对事务提案进行背书。

将已背书的事务提交到订购服务。

等待事务提交，更新账本状态。

示例应用程序的’’InitLedger’’调用如下：

. code-block:: TypeScript

await contract.submitTransaction(‘InitLedger’);

第五，调用事务函数以读取和写入资产¶

现在应用程序已准备好执行业务逻辑，通过调用智能合约上的事务函数来查询、创建额外资产以及修改账本上的资产。

查询所有资产¶

应用程序使用``evaluateTransaction()``通过执行只读事务调用来查询账本。evaluateTransaction()

将使用Fabric Gateway来调用事务函数并返回其结果。该事务不会被发送到订购服务,也不会导致账本更新。

以下是示例应用程序获取在之前的步骤中我们填充账本时创建的所有资产。

示例应用程序的``GetAllAssets``调用如下：

const resultBytes = await contract.evaluateTransaction('GetAllAssets');

const resultJson = utf8Decoder.decode(resultBytes);

const result = JSON.parse(resultJson);

console.log('*** Result:', result);

note: 事务函数的结果始终以字节返回,因为事务函数可以返回任何类型的数据。

通常,事务函数返回字符串;或者在上面的情况下,返回JSON数据的UTF-8编码字符串。

应用程序有责任正确解析结果字节。

终端输出应该看起来如此：

*** Result: [

{

AppraisedValue: 300,

Color: 'blue',

ID: 'asset1',

Owner: 'Tomoko',

Size: 5,

docType: 'asset'

{

AppraisedValue: 400,

Color: 'red',

ID: 'asset2',

Owner: 'Brad',

Size: 5,

docType: 'asset'

{

AppraisedValue: 500,

Color: 'green',

ID: 'asset3',

Owner: 'Jin Soo',

Size: 10,

docType: 'asset'

{

AppraisedValue: 600,

Color: 'yellow',

ID: 'asset4',

Owner: 'Max',

Size: 10,

docType: 'asset'

{

AppraisedValue: 700,

Color: 'black',

ID: 'asset5',

Owner: 'Adriana',

Size: 15,

docType: 'asset'

{

AppraisedValue: 800,

Color: 'white',

ID: 'asset6',

Owner: 'Michel',

Size: 15,

docType: 'asset'

}

]

创建新资产¶

示例应用程序提交一个事务来创建新资产

示例应用程序的``CreateAsset``调用如下：

const assetId = `asset${Date.now()}`;

await contract.submitTransaction(

'CreateAsset',

assetId,

'yellow',

'5',

'Tom',

'1300',

);

note: 在上面的应用程序片段中，重要的是要注意，``CreateAsset``事务使用与链码期望的相同类型和数量的参数以及正确的顺序进行提交。

在这种情况下，正确排序的参数如下：

assetId, "yellow", "5", "Tom", "1300"

相应的智能合约的``CreateAsset``事务函数期望以下顺序的参数来定义资产对象:

ID, Color, Size, Owner, AppraisedValue

更新资产¶

示例应用程序提交一个事务来转移新创建资产的所有权。这次，使用``submitAsync()``调用事务，

该调用在成功提交已背书的事务给订购服务后返回，而不是等待事务提交到账本。这允许应用程序在等待事务提交时使用事务结果执行工作。

示例应用程序的``TransferAsset``调用如下：

const commit = await contract.submitAsync('TransferAsset', {

arguments: [assetId, 'Saptha'],

});

const oldOwner = utf8Decoder.decode(commit.getResult());

console.log(`*** Successfully submitted transaction to transfer ownership from ${oldOwner} to Saptha`);

console.log('*** Waiting for transaction commit');

const status = await commit.getStatus();

if (!status.successful) {

throw new Error(`Transaction ${status.transactionId} failed to commit with status code ${status.code}`);

}

console.log('*** Transaction committed successfully');

终端输出：

*** Successfully submitted transaction to transfer ownership from Tom to Saptha

*** Waiting for transaction commit

*** Transaction committed successfully

查询更新后的资产¶

示例应用程序然后评估了已转移资产的查询，显示它是如何根据描述创建的，然后随后转移到新所有者。

示例应用程序的’’ReadAsset’’调用如下:

const resultBytes = await contract.evaluateTransaction('ReadAsset', assetId);

const resultJson = utf8Decoder.decode(resultBytes);

const result = JSON.parse(resultJson);

console.log('*** Result:', result);

终端输出：

*** Result: {

AppraisedValue: 1300,

Color: 'yellow',

ID: 'asset1639084597466',

Owner: 'Saptha',

Size: 5

}

处理事务错误¶

序列的最后部分演示了提交事务时发生错误。在这个示例中，应用程序尝试提交一个``UpdateAsset``事务,

但指定了一个不存在的资产ID。事务函数返回错误响应,``submitTransaction()``调用失败。

``submitTransaction()``的失败可能会生成多种不同类型的错误，指示错误发生在提交流程的哪个点，

并包含附加信息以使应用程序能够适当地响应。请参考`API文档`_

以获取可能生成的不同错误类型的详细信息。

示例应用程序中失败的``UpdateAsset``调用如下：

try {

await contract.submitTransaction(

'UpdateAsset',

'asset70',

'blue',

'5',

'Tomoko',

'300',

);

console.log('******** FAILED to return an error');

} catch (error) {

console.log('*** Successfully caught the error: \n', error);

}

终端输出（为了清晰起见，已删除堆栈跟踪）：

*** Successfully caught the error:

EndorseError: 10 ABORTED: failed to endorse transaction, see attached details for more info

at ... {

code: 10,

details: [

{

address: 'peer0.org1.example.com:7051',

message: 'error in simulation: transaction returned with failure: Error: The asset asset70 does not exist',

mspId: 'Org1MSP'

}

cause: Error: 10 ABORTED: failed to endorse transaction, see attached details for more info

at ... {

code: 10,

details: 'failed to endorse transaction, see attached details for more info',

metadata: Metadata { internalRepr: [Map], options: {} }

transactionId: 'a92980d41eef1d6492d63acd5fbb6ef1db0f53252330ad28e548fedfdb9167fe'

}

‘’EndorseError’’类型表示在认可过程中发生了故障,而’’ABORTED’’’ gRPC状态代码_ 表示应用程序成功调用了Fabric Gateway,

但在认可过程中发生了故障。’’UNAVAILABLE’’或’’DEADLINE_EXCEEDED’’ gRPC状态代码可能表明Fabric Gateway不可访问或未及时收到响应,因此可能需要重试该操作。

清理¶

当您完成使用资产转移示例后，可以使用’’network.sh’’ 脚本关闭测试网络：

.. code-block:: bash

./network.sh down

该命令将关闭我们创建的区块链网络的证书颁发机构、对等节点和排序节点。

请注意，将丢失帐本上的所有数据。如果您想再次运行教程，您将从干净的初始状态开始。

总结¶

您已经学会了如何通过启动测试网络和部署智能合约来建立区块链网络。然后,

您运行了一个客户端应用程序,并检查了应用程序代码,以了解它如何使用Fabric Gateway

客户端API连接到Fabric Gateway并调用已部署的智能合约的事务功能来查询和更新帐本。

这个教程为您提供了与Hyperledger Fabric一起工作的亲身体验。

This work is licensed under a Creative Commons Attribution 4.0 International License

Revision b9b6b2b6.

Built with Sphinx using a theme provided by Read the Docs.

Read the Docs

v: latest

Versions

latest

release-2.5

fabric-ca-release1.4

Downloads

html

On Read the Docs

Project Home

Builds

一个企业级区块链平台 — hyperledger-fabricdocs master 文档

hyperledger-fabricdocs

latest

我们是谁

介绍

Hyperledger Fabric v2.0 更新说明

发行说明

关键概念

入门

开发应用

教程

部署一个生产网络

操作指南

升级到最新版本

命令参考

架构参考

常见问题

欢迎贡献！

术语表

版本发布

仍有问题？

状态

hyperledger-fabricdocs

一个企业级区块链平台

Edit on GitHub

注解

请确认您正在阅读的文档和您使用的软件版本相匹配。左边的导航栏顶部可以看到版本标志。您可以使用导航栏下边的选择器切换版本。

一个企业级区块链平台¶

企业级授权分布式账本平台为大多数行业的应用场景提供模块化和广泛的支持。

我们是谁

介绍

Hyperledger Fabric v2.0 更新说明

发行说明

关键概念

入门

开发应用

教程

部署一个生产网络

操作指南

升级到最新版本

命令参考

架构参考

常见问题

欢迎贡献！

术语表

版本发布

仍有问题？

状态

注解

如果您的问题没在本文档中找到解决方案，或者运行教程时有任何问题，请访问仍有问题？页面查找答案或者请求额外帮助。

This work is licensed under a Creative Commons Attribution 4.0 International License

Revision b9b6b2b6.

Built with Sphinx using a theme provided by Read the Docs.

Read the Docs

v: latest

Versions

latest

release-2.5

fabric-ca-release1.4

Downloads

html

On Read the Docs

Project Home

Builds

Follow

tp钱包官网|hyperledger fabric教程

tp钱包官网|hyperledger fabric教程

hyperledger fabric教程资源 - 知乎

万字解析——区块链hyperledger fabric2.2部署实战教程_hyperledger fabric教程-CSDN博客

【hyperledger fabric 教程】1.ubuntu 安装fabric并运行起来 - 知乎

入门 — hyperledger-fabricdocs master 文档

编写第一个应用 - Hyperledger中文文档

快速入门 - Hyperledger中文文档

Fabric 介绍 — Hyperledger Fabric 中文文档 文档

Hyperledger Fabric 小白入门指南 - 知乎

编写一个 Fabric 应用 — hyperledger-fabricdocs master 文档

一个企业级区块链平台 — hyperledger-fabricdocs master 文档

最近的新闻

您可能喜欢的文章

tokenpocket官方下载|卢布为什么不值钱

imtoken安卓版app软件|ape8无损音乐

如何将TP钱包提现到欧易？

TP钱包显示获取代币列表失败：原因与解决方法

TP钱包代币提交后多久会显示？

比特币钱包取消同步：简单易懂的解决方案

数字货币短线牛人，成为数字货币交易中的佼佼

Fabric 介绍 — Hyperledger Fabric 中文文档文档