본 블로그 중 '[블록체인] 하이퍼레저 > [하이퍼레저] 공식문서 번역본 ' 하위의 포스팅된 글은

하이퍼레저 패브릭 공식 사이트의 ' release-1.1'의 doc  부분을 번역한 자료 입니다.

 

스터디를 하면서 1차 번역후 포스팅 한 것으로 잘못 번역된 부분이 있습니다.

월간, 블록체인 멤버들이 시간날때 조금씩 짬짬히  번역을 손보고 있으니..

너그러이 이해해주시고..

이점 참고하여 보시기 바랍니다.

 

또한 포스팅 순서가 목차와 동일하지 않아  이해가 어려울 수 있으므로

아래의 목차를 참조하여 포스팅글을 보시면 하이퍼레저 패브릭 문서를 보시는데 도움이 되시리라 생각합니다.

(아래 목차에 본 블로그의 포스팅과 링크를 걸어두었습니다.)

 

 

HyperLedger Fabric Table of Contents


1. Getting Started

Install Prerequisites
Install Binaries and Docker Images
Hyperledger Fabric Samples
API Documentation
Hyperledger Fabric SDKs
Hyperledger Fabric CA


2. Key Concepts

Introduction
Hyperledger Fabric Functionalities
Hyperledger Fabric Model
Identity
Membership

Peers
Ledger
Use Cases


 

3. Tutorials

Building Your First Network
Writing Your First Application
Adding an Org to a Channel
Upgrading Your Network Components
Chaincode Tutorials
Chaincode for Developers
Chaincode for Operators
System Chaincode Plugins
Videos

 

4. Operations Guides

Upgrading from v1.0.x
Updating a Channel Configuration
Membership Service Providers (MSP)
Channel Configuration (configtx)
Endorsement policies
Error handling
Logging Control
Securing Communication With Transport Layer Security (TLS)
Bringing up a Kafka-based Ordering Service

 

5. Commands Reference

peer command
peer chaincode
• peer channel
peer version
peer logging
peer node
configtxgen
configtxlator
Cryptogen Commands
Fabric-CA Commands

 

6. Architecture Reference

Architecture Explained
Transaction Flow
Hyperledger Fabric CA’s User Guide
• Hyperledger Fabric SDKs
Channels
Capability Requirements
CouchDB as the State Database
Peer channel-based event services
Read-Write set semantics
Gossip data dissemination protocol

 

7. Hyperledger Fabric FAQ

Endorsement

• Security & Access Control

Application-side Programming Model

Chaincode(Smart Contracts and Digital Assets)

Differences in Most Recent Releases


8. Ordering Service FAQ

General

Solo

Kafka
BFT
 

 

9. Contributions Welcome!

10.Glossary

 

 

Fabric CA User’s Guide

 

 

출처 : http://hyperledger-fabric.readthedocs.io/en/release-1.1/#


 

  •  하이퍼레저의 구성요소

 

구성요소

설명

비고

Network

Channel

명시적으로 인가된 특정 Member(PeerApplication)ledger 공유하기 위한 Private blockchain 가상  network (overlay)

CA

Hyperledger의 모든 구성요소 인증서 발급

Member

BC_NW내의 PeerApplication의 집합
Root 인증서를 가진 Entity

Organization

Peer 관리하는 조직 (논리적 단위)

MSP

회원등록을 위한 규칙 및 Access control 및 권한 부여를 설정할 수 있는 Identity 관리 서비스

Orderers

KAFKAZookeeper를 통해서 BC_NW 에서 Streaming 서비스 함

Peer

Ledger를 유지하고, 체인코드를 실행할 수 있는 network entity

Ledger

순차적이고, 변조불가능한 데이터들을 체인 형태로 구성한 개념(공유원장, 분산원장)
구성요소 : World StateTransaction Log 구성 ,

Transaction

유형 : Depoly(Install), Invoke (Write)

Consensus

PBFT 개념을 Hyperledger fabric이 구현한 ABC(Atomic BroadCast) 합의알고리즘 사용
합의 = Endorsement + Ordering + Validation
ABC 합의 알고리즘은 KAFKA에서 지원
KAFKA수행 방법;  Permissioned voting based. Leader does ordering. Only in-sync replicas can be voted as leader.
Consensus 결정되면 설정변경 불가능

Chaincode

Ledger상에서 실행되는 소프트웨어로 비즈니스 로직을 포함하고 있음
ChainCode는 여러 개의 함수를 가질 수 있으며 이를 ChainCode Function이라고 함

 

 

 

  •  하이퍼레저의 주요 구성요소  
  •  

    구분

    소분류

    설명

    트랜잭션

    배포 트랜잭션

    배포 트랜잭션은 단어 그대로 체인코드를 블록체인의 시스템에 설치하기 위해 실행되며, 배포 트랜잭션이 호출되면 체인코드를 빌드하고 피어에 설치하며 초기값을 파라미터로 받아서 블록에 저장하는 과정을 거친다.

    Invoke
    트랜잭션

    배포된 체인코드를 기준으로 정의된 함수를 호출하기 위해 실행된다. Invoke트랜잭션을 호출한 결과, 호출이 정상적으로 완료되면 스테이트에 처리 결과가 저장되고 결과는 호출한 클라이언트에 반환된다.
    Invoke Transaction 유형 : Invoke, Query

    블록체인
    데이터 구조

    스테이트(State)

    블록체인에서 최신 State는 버전관리 키-밸류스토어(KVS : Key Value Store ) 설계되어 있다. KVS에 문자열 타입의 키와 임의의 객체인 밸류로 저장가능하며, 블록체인에서 구동되고 있는 체인코드에서 "PUT", "GET" 동작에 의해 관리 된다. 키-밸류 스토어는 동시에 버전 정보를 함께 저장하고 있어서 동일한 키 값으로 입력되는 밸류에 대해 버전관리가 이루어 진다. 그러므로 모든 트랜잭션 되는 데이터에 대해서는 히스토리 관리가 된다.

    원장(Ledger)

    원장은 블록체인에서 모든 성공 또는 실패한 스테이트의 변경에 대한 검증 가능한 기록을 저장한다. 원장은 Ordering서비스에 의해 완벽하게 순차 처리된 트랜잭션의 해시 체인으로 구성되며, 해시 체인은 원장에 블록의 전체 순서를 지정하며 각 블록에는 순차로 정렬된 트랜잭션 배열이 포함된다.
    원장은 모든 피어와 일부 Orderer에서 저장되고 관리 된다. 피어에는 원장과 스테이트가 관리되는데, 역할에 따라서 Committing Peer와 Endorsing Peer로 구분되며 Endorsing Peer에 의해 검증된 트랜잭션뿐 아니라 검증에 실패한 트랜잭션의 정보도 비트 구분을 통해 함께 관리 한다. Orderer는 결함 허용(Fault-tolerance)정보와 피어의 가용성 정보를 원장으로 관리한다.

    노드(Node)

    블록체인에서 노드는 통신을 위한 엔티티 말하며, 같은 유형의 여러 노드가 동일한 서버에서 구동 될 수 있다는 점에서 논리적인 기능으로 구분되는 단위이다. 노드는 크게 세가지로 구분된다.
    클라이언트 : 트랜잭션을 발생시켜 Endorser에게 트랜잭션을 제안(Proposal)하고 Endorsing결과를 받아서 최종적으로 Orderer에게 트랜잭션을 전송하는 역할을 하는 노드
    피어 : 트랜잭션을 커밋하고 원장을 관리가 주된 역할이며, 설정에 의해 Endorser의 역할을 할 수도 있따.
    Ordering 서비스 노드(또는 Orderer): 트랜잭션에 대해 각 피어에게 일관되게 동일한 원장을 관리 할 수 있도록 커뮤니케이션을 보장하는 역할의 노드

     

     

     

    * 하이퍼레저 표준 문서 등을 기준으로 정리했습니다. 오기 등이 포함되어 있을 수 있습니다.

    원장

    원장 (ledger)은 모든 State 전이에 대해 순서를 변경하고 변조를 방지하는 기록입니다. State 전이는 참여 당사자가 제출 한 체인 코드 호출 ( "트랜잭션")의 결과입니다. 각 트랜잭션은 생성, 갱신 또는 삭제와 같이 원장에게 커밋되는 일련의 자산 키 - 값 쌍을 생성합니다.

    원장은 불변의 시퀀스 된 레코드를 블록으로 저장하는 블록 체인 (chainchain)과 현재 State를 유지하는 State 데이터베이스로 구성됩니다. 채널 당 1 개의 원장이 있습니다. 각 피어는 회원 인 각 채널에 대해 원장 사본을 보관합니다.

    체인

    체인은 각 블록에 N 개의 트랜잭션 시퀀스가 ​​들어있는 해시 - 링크 블록으로 구성된 트랜잭션 로그입니다. 블록 헤더는 이전 블록의 헤더 해시뿐만 아니라 블록 트랜잭션의 해시를 포함합니다. 이렇게하면 원장의 모든 트랜잭션이 순서가 지정되고 함께 암호로 링크됩니다. 즉 해시 링크를 손상시키지 않고 원장 데이터를 무단으로 변경할 수 없습니다. 최신 블록의 해시는 이전의 모든 트랜잭션을 나타내므로 모든 피어가 일관되고 신뢰할 수있는 State에있음을 보장 할 수 있습니다.

    체인은 피어 파일 시스템 (로컬 또는 연결된 스토리지)에 저장되어 효율적으로 블록 체인 작업 부하의 추가 전용 특성을 지원합니다.

    State Database 

    원장의 현재 State 데이터는 체인 트랜잭션 로그에 포함 된 모든 키의 최신 값을 나타냅니다. 현재 State는 채널에 알려진 모든 최신 키 값을 나타내므로 때로는 World State 라고합니다.

    체인 코드 호출은 현재 State 데이터에 대해 트랜잭션을 실행합니다. 이러한 체인 코드 상호 작용을 매우 효율적으로 만들기 위해 모든 키의 최신 값이 State 데이터베이스에 저장됩니다. State 데이터베이스는 단순히 체인의 트랜잭션 로그에 대한 인덱싱 된 뷰이므로 언제든지 체인에서 다시 생성 할 수 있습니다. State 데이터베이스는 트랜잭션이 수락되기 전에 피어 시작시 자동으로 복구됩니다 (또는 필요한 경우 생성됩니다).

    State 데이터베이스 옵션에는 LevelDB 및 CouchDB가 포함됩니다. LevelDB는 피어 프로세스에 포함 된 기본 State 데이터베이스이며 키 코드 값 쌍으로 체인 코드 데이터를 저장합니다. CouchDB는 체인 코드 데이터를 JSON으로 모델링 할 때 추가 쿼리 지원을 제공하는 선택적 대체 외부 State 데이터베이스로서 JSON 컨텐트에 대한 풍부한 쿼리를 허용합니다. 참조) State 데이터베이스로 CouchDB를을 CouchDB를에 대한 자세한 정보를 얻을 수 있습니다.

    Transaction흐름

    높은 수준에서 트랜잭션 흐름은 응용 프로그램 클라이언트가 특정 승인하는 동료에게 보내는 트랜잭션 제안으로 구성됩니다. Endorsing 피어는 클라이언트 서명을 확인하고 체인 코드 기능을 실행하여 트랜잭션을 시뮬레이트합니다. 출력은 chaincode 결과, chaincode (읽기 세트)에서 읽은 key- value Version Set 및 chaincode (쓰기 세트)로 작성된 key / Value 세트입니다. Proposal 응답은 보증 서명과 함께 고객에게 반송됩니다.

    클라이언트는 Endorsment Node로 트랜잭션 페이로드를 어셈블하고이를 Ordering 서비스로 브로드 캐스트합니다. Ordering 서비스는 정렬 된 트랜잭션을 채널의 모든 피어에게 블록으로 전달합니다.

    committal 전에 동료는 트랜잭션을 확인합니다. 먼저 지정된 피어의 정확한 할당이 결과에 서명하고 트랜잭션 payload에 대해 서명을 인증하는지 확인하기 위해 Endorsement Policy을 확인합니다.

    둘째, 동료는 데이터 무결성을 보장하고 이중 지출과 같은 위협으로부터 시스템을 보호하기 위해 트랜잭션 읽기 세트에 대한 버전 확인을 수행합니다. Hyperledger Fabric은 트랜잭션을 병렬 처리하여 (엔도 서별로) 처리량을 늘리고 모든 피어가 커밋시 다른 트랜잭션이 읽은 데이터를 수정하지 않았는지 확인합니다. 즉, 체인 코드 실행 중에 읽은 데이터가 실행 (승인) 시간 이후 변경되지 않았으므로 실행 결과가 여전히 유효하며 원장 State 데이터베이스에 커밋 될 수 있습니다. 읽은 데이터가 다른 트랜잭션에 의해 변경된 경우 블록의 트랜잭션은 유효하지 않은 것으로 표시되고 원장 State 데이터베이스에 적용되지 않습니다. 클라이언트 응용 프로그램에 경고가 표시됩니다.

    참고 항목 트랜잭션 흐름 , 세트 의미를 읽기 - 쓰기 및 국가 데이터베이스로 CouchDB를 트랜잭션구조, 동시성 제어 및 State DB에 깊은 다이빙에 대한 항목을 참조하십시오.

    블록 체인 네트워크는 주로 피어 노드 집합으로 구성됩니다. 원장 및 Smart Contract를 호스팅하기 때문에 원장은 네트워크의 기본 요소입니다. 원장은  Smart Contract에 의해 생성 된 모든 트랙잭션을 수정 불가능 하도록 기록한다는 점을 기억하셔야합니다. Smart Contract 및 원장은 공유 프로세스정보 를 각각의 네트워크 에 캡슐화하기 위해서 사용됩니다 . 피어의 이러한 측면은 Hyperledger Fabric 네트워크를 이해하는 데 좋은 시작점이됩니다.

    원장 및 Smart Contract, Orderer, 정책, 채널, 어플리케이션, 조직, ID 및 멤버십과 같은 블록 체인 네트워크의 다른 요소도 물론 중요합니다. 그리고 자신의 전용 토픽에 대해 자세히 알아볼 수 있습니다. 이 토픽는 피어 및 Hyperledger Fabric 블록 체인 네트워크의 다른 요소와의 관계에 중점을 둡니다.


    블록 체인 네트워크는 피어 노드로 구성되며 각 노드는 원장 및 Smart Contract 사본을 보유 할 수 있습니다. 이 예시를 보시면 네트워크 N은 피어 P1, P2 및 P3에 의해 형성됩니다. P1, P2 및 P3은 각각 원장 L1의 자체 인스턴스를 유지합니다. P1, P2, P3는 체인 코드 S1을 사용하여 원장 L1 사본에 액세스합니다.

     

    피어는 생성, 시작, 중지, 재구성 및 삭제될 수 있습니다. 관리자와 어플리케이션이 제공하는 서비스와 상호 작용할 수있는 일련의 API를 제공합니다. 이 주제에 대한 자세한 내용은 이 서비스를 참조하십시오.

    전문 용어

    Hyperledger Fabric은 chaincode 라고하는 기술 개념을 사용하여 Smart Contract을 구현합니다. Smart Contract란 지원되는 프로그래밍 언어 중 하나로 작성된 원장에 접근하는 간단한 코드입니다. 이 주제에서는 일반적으로 chaincode 라는 용어를 사용하겠지만, 이 용어를 사용하는 것이 익숙하시다면 Smart Contract 토픽을 읽으십시오 . 물론 Chaincode와 Smart Contract는 같은 주제입니다.

    원장 및 체인 코드

    피어를 조금 더 자세히 살펴 보겠습니다. 원장과 체인 코드를 모두 호스트하는 것이 피어임을 알 수 있습니다. 더 정확하게, 피어는 실제로 Instance 원장과 Instance chaincode를 호스팅합니다. 이는 Fabric 네트워크에서 고의적 이중화를 제공합니다. 그리고 그로 인해 단일 실패 지점을 피할 수 있습니다. 이 주제의 뒷부분에선 블록 체인 네트워크의 분산 된 특성에 대해 더 배우게됩니다.


    피어는 원장의 인스턴스와 체인 코드의 인스턴스를 호스팅합니다. 이 예에서 P1은 원장 L1의 인스턴스와 체인 코드 S1의 인스턴스를 호스팅합니다. 개별 피어에서 호스팅되는 다양한 원장과 체인 코드가 있을 수 있습니다.

    피어는 원장 및 체인 코드 의 호스트 이기 때문에 애플리케이션 및 관리자는 이러한 리소스에 액세스하려는 경우 피어와 상호 작용해야합니다. 이것이 피어가 Hyperledger Fabric 블록 체인 네트워크의 가장 기본적인 빌딩 블록으로 간주되는 이유입니다. 피어가 처음 만들어지면 원장이나 체인 코드를 가지고 있지 않습니다. 원장이 어떻게 생성되고 체인 코드가 설치되는지 나중에 알게 될 것입니다.

    복수 원장

    피어는 둘 이상의 원장을 호스팅 할 수 있고 유연한 시스템 설계가 가능해서 도움이됩니다. 가장 단순한 피어 구성은 하나의 원장을 갖는 것이지만 필요에 따라 피어가 둘 이상의 원장을 호스팅하는 것이 적합할 때도 있습니다.


    여러 원장을 호스팅하는 피어입니다. 피어는 하나 이상의 원장을 호스팅하고 각 원장에는 0 개 이상의 체인 코드가 적용됩니다. 위의 사진에서 피어 P1이 원장 L1 및 L2를 호스팅한다는 것을 알 수 있습니다. 원장 L1은 체인 코드 S1을 사용하여 액세스됩니다. 원장 L2는 체인 코드 S1 및 S2를 사용하여 액세스 할 수 있습니다.

    피어가 액세스하는 체인 코드를 호스팅하지 않고 원장 인스턴스를 호스팅하는 것이 완벽하게 가능할 수도 있지만 피어가 이와 같이 구성되는 것은 매우 드뭅니다. 대다수의 피어는 피어의 원장 인스턴스를 쿼리하거나 업데이트 할 수있는 체인 코드가 하나 이상 설치됩니다. 사용자가 외부 어플리케이션에서 사용할 수 있도록 체인 코드를 설치했는지에 대한 여부를 전달하는 것에 있어 언급 할 가치가 있으며, 피어는 항상 존재하는 특별한 시스템 체인 코드 도 가지고 있습니다 . 이 항목에서는 이러한 항목에 대해 자세히 설명하지 않습니다.

    다중 Chain Code

    피어가 가지고있는 원장의 수와 해당 원장에 액세스 할 수있는 체인 코드의 수 사이에는 고정된 관계가 없습니다. 피어는 많은 체인 코드와 많은 원장을 사용할 수 있습니다.


    여러 체인 코드를 호스팅하는 피어의 예입니다. 각 원장에는 다수의 체인 코드가있어 액세스 할 수 있습니다. 이 예에서 피어 P1은 원장 L1 및 L2를 호스팅한다는 것을 알 수 있습니다. L1은 체인 코드 S1 및 S2에 의해 액세스되는 반면 L2는 S3 및 S1에 의해 액세스됩니다. S1은 L1과 L2 모두에 액세스 할 수 있음을 알 수 있습니다.

    우리는 이후 피어에게 여러 원장이나 여러 개의 체인 코드를 호스팅 할 때 Hyperledger Fabric 의 Channel 개념 이 중요한 이유를 알아 보겠습니다.

    어플리케이션 및 피어

    이제 어플리케이션이 피어와 상호 작용하여 원장에 액세스하는 방법을 보여 드리겠습니다. 원장 - 쿼리 상호 작용에는 어플리케이션과 피어간에 간단한 3 단계 대화가 포함됩니다. 장부 - 갱신 상호 작용은 좀 더 복잡하고 두 가지 추가 단계가 필요합니다. Hyperledger Fabric을 시작하는 데 도움이 되도록 단계를 단순화했지만 걱정하지 마십시오. 원장 쿼리의 원장 업데이트 트랜잭션 스타일과 비교하여 어플리케이션 - 피어 상호 작용의 차이점을 이해하는 것이 가장 중요합니다.

    원장 및 체인 코드에 액세스해야하는 경우 항상 피어에 연결됩니다. Hyperledger Fabric Software Development Kit(SDK)을 사용하면 프로그래머가 쉽게 어플리케이션을 작성할 수 있습니다. API를 사용하여 어플리케이션에서 피어에 연결하고 체인 코드를 호출하여 트랜잭션을 생성하고 네트워크에 트랜잭션을 제출하여 Order을 받고 분산 원장에게 커밋하고 이벤트를 수신 할 수 있을 때 이 과정이 완료된 것입니다.

    피어 연결을 통해 어플리케이션은 체인 코드를 실행하여 장부를 쿼리하거나 업데이트 할 수 있습니다. 장부 쿼리 트랜잭션의 결과는 즉시 반환되는 반면 원장 업데이트는 어플리케이션, 피어 및 Orderer의 상호작용보다 더욱 복잡한 상호 작용을 수반합니다. 조금 더 자세하게 조사해 봅시다.


    피어는 Orderer와 함께 모든 원장에게 장부가 최신 State로 유지되도록합니다. 이 예제에서 어플리케이션 A는 P1에 연결하고 체인 코드 S1을 호출하여 원장 L1을 쿼리하거나 업데이트합니다. P1은 S1을 호출하여 쿼리 결과 또는 제안 된 원장 갱신을 포함하는 제안 응답을 생성합니다. 어플리케이션 A가 제안 응답을 받고 쿼리에 대해 프로세스가 완료되었습니다. 업데이트의 경우 A는 모든 응답에서 트랜잭션을 작성하고 Order를 위해 O1로 전송합니다. O1은 네트워크에서 블록으로 트랜잭션을 수집하여이를 P1을 포함한 모든 피어에 배포합니다. P1은 L1에 적용하기 전에 트랜잭션의 유효성을 검사합니다. L1이 업데이트되면, P1은 A가 수신 한 이벤트를 생성하여 완료를 나타냅니다.

    피어는 쿼리 요구에 필요한 모든 정보가 피어의 원장 사본에 있으므로 쿼리 결과를 즉시 어플리케이션에 반환 할 수 있습니다. 피어는 다른 피어와 소통하여 어플리케이션에 쿼리를 반환하지 않습니다. 그러나 어플리케이션은 하나 이상의 피어에 연결하여 쿼리를 발행 할 수 있습니다. 예를 들어 여러 피어간에 결과를 확증하거나 정보가 부족한 것으로 의심되는 경우 다른 피어에서 최신 결과를 검색 할 수 있습니다. 날짜. 다이어그램에서 원장 쿼리는 간단한 3 단계 프로세스임을 알 수 있습니다.

    업데이트 트랜잭션은 쿼리 트랜잭션과 동일한 방식으로 시작되지만 두 가지 추가 단계가 있습니다. 이라는 프로세스 - 원장 - 어플리케이션 업데이트도 원장 - 쿼리 어플리케이션과 달리 chaincode를 호출하는 피어에 연결할 수 있지만 다른 피어 먼저 변경에 동의해야하기 때문에, 개인 피어는이 시간에 원장 업데이트를 수행 할 수 없습니다 합의 . 따라서 피어는 제안 된 업데이트 (이 피어가 다른 피어의 사전 동의에 따라 적용될 업데이트)를 어플리케이션에 반환합니다 . 첫 번째 단계 인 네 번째 단계에서는 어플리케이션이 제안 된 업데이트와 일치하는 적절한 집합을 피어 네트워크 전체에 보내어 각 원장에 대한 약정을 위한 트랜잭션으로 전달해야합니다. 이것은 Ordere 사용하는 어플리케이션에 의해 달성됩니다. 트랜잭션을 블록으로 패키지화하고 이를 피어의 전체 네트워크에 배포하며, 각 피어의 원장 사본에 적용되기 전에 이를 확인할 수 있습니다. 이 전체 Order 처리가 완료되는 데 몇 시간이 걸리므로 5 단계 에서처럼 어플리케이션에 비동기 적으로 통지됩니다.

    이 항목의 뒷부분에서이 Order Process의 세부적인 특성에 대해 자세히 알아보고이 프로세스에 대한 자세한 내용은 트랜잭션 흐름 항목을 참조하십시오 .

    피어 및 채널

    이 주제는 채널이 아닌 피어에 관한 내용이지만 피어가 서로 상호 작용하는 방식을 이해하고 채널을통해 어플리케이션을 이해하는 데 약간의 시간을 투자 할 가치가 있습니다. 블록 체인 네트워크 내의 구성 요소 집합이 개인적으로 통신하고 상호 작용할 수 있는 메커니즘 입니다.

    이러한 구성 요소는 일반적으로 피어 노드, 발주자 노드 및 어플리케이션이며 채널에 가입함으로써 함께 모여 해당 채널에 대한 원장의 동일한 복사본을 공동으로 공유하고 관리하는 데 동의합니다. 개념적으로 채널은 친구 그룹과 유사하다고 생각할 수 있습니다 (채널 회원은 확실히 친구 일 필요는 없습니다!). 한 사람에게는 여러 그룹의 친구가있을 수 있으며, 각 그룹에는 함께하는 활동이 있습니다. 이 그룹들은 완전히 별개의 그룹 일 수도 있고 (취미 친구들의 그룹과 비교하여 일하는 친구 그룹 일 수도 있습니다.), 또는 그들 사이에 크로스 오버가있을 수 있습니다. 그럼에도 불구하고 각 그룹은 일종의 "규칙"을 가진 자체 엔티티입니다.


    채널을 사용하면 특정 피어 집합과 어플리케이션 집합이 블록 체인 네트워크 내에서 서로 통신 할 수 있습니다. 이 예시에서, 어플리케이션 A는 채널 C를 사용하여 피어 P1 및 P2와 직접 통신 할 수 있습니다.이 채널을 특정 어플리케이션과 피어 간의 통신 경로로 생각할 수 있습니다. (간략하게하기 위해 해당 다이어그램에는 Orderer가 표시되지 않지만 제대로 작동하는 네트워크에 있어야합니다.)

    우리는 피어들이하는 것과 같은 방식으로 채널이 존재하지 않는다는 것을 알았습니다. 채널을 물리적 피어 집단에 의해 형성된 논리적 구조로 생각하는 것이 더 적절합니다. 이 것을 이해하는 것이 중요합니다. 피어는 채널에 대한 액세스 및 관리를 위한 제어 지점을 제공합니다 .

    피어 및 조직

    이제 피어와 원장, 체인 코드 및 채널과의 관계를 이해하면 여러 조직이 모여 블록 체인 네트워크를 구성하는 방법을 알 수 있습니다.

    블록 체인 네트워크는 단일 조직 이라기보다는 조직의 집합에 의해 관리됩니다. 피어들은 이러한 종류의 분산 네트워크가 이러한 조직에 의해 소유되고 네트워크에 대한 연결 지점이기 때문에 구축되는 방식의 핵심입니다.


    여러 조직이있는 블록 체인 네트워크의 피어. 블록 체인 네트워크는 다른 조직이 소유한 피어들로 구성됩니다. 이 예에서는 네트워크를 형성하기 위해 8 명의 피어에 기여하는 4 개의 조직을 볼 수 있습니다. 채널 C는 네트워크 N-P1, P3, P5, P7 및 P8에서 이러한 피어 중 다섯 개를 연결합니다. 이 조직이 소유 한 다른 피어는이 채널에 가입하지 않았지만 일반적으로 하나 이상의 다른 채널에 가입합니다. 특정 조직에서 개발 한 어플리케이션은 다른 조직의 어플리케이션과 마찬가지로 자신의 조직의 피어와 연결됩니다. 다시 말하지만, 간단하게하기 위해이 다이어그램에는 Orderer 노드가 표시되지 않습니다.

    블록 체인 네트워크의 형성 과정을 파악할 수 있어야합니다. 네트워크는 자원을 제공하는 여러 조직에 의해 형성되고 관리됩니다. 피어는이 항목에서 논의하는 리소스이지만 조직에서 제공하는 리소스는 단순한 것 이상입니다. 여기서 일하는 원칙이 있습니다. 네트워크가 말 그대로 조직이 개별 리소스를 집단 네트워크에 기여하지 않으면 존재하지 않습니다. 또한 네트워크는 이러한 공동 작업 조직에서 제공하는 리소스로 확장 및 축소됩니다.

    위 의 예 에서 조직이 피어를 제공하지 않은 경우 네트워크 ( N )가 존재하지 않는다는 것을 볼 수 있습니다 (Ordering Service 이외). 중앙 리소스 가 없습니다. 이는 조직이 조직에서 자원을 기여할 때까지 그리고 조직이 자원을 기여할 때까지 네트워크가 의미있는 의미로 존재하지 않는다는 사실을 반영합니다. 또한 네트워크는 개별 조직에 의존하지 않습니다. 어떤 조직이 어떤 조직에 출입 할지라도 조직이 남아있는 한 계속 존재할 것입니다. 이것은 네트워크가 분산화된다는 의미의 중심에 있습니다.

    위의 예시와 같이 다른 조직의 어플리케이션 은 동일하거나 다를 수 있습니다. 그 이유는 어플리케이션이 피어의 원장 사본을 어떻게 처리하는지는 전적으로 조직에 달려 있기 때문입니다. 즉, 각각의 피어가 정확히 동일한 원장 데이터를 호스팅하더라도 어플리케이션 논리와 표시 논리가 조직마다 다를 수 있음을 의미합니다.

    어플리케이션은 필요한 원장 상호 작용의 특성에 따라 조직의 피어 또는 다른 조직의 피어와 연결됩니다. 원장 - 쿼리 상호 작용의 경우 일반적으로 어플리케이션이 자체 조직의 피어와 연결됩니다. 원장 - 업데이트 상호 작용의 경우 원장 업데이트를 승인하는 데 필요한 모든 조직의 피어에게 어플리케이션을 연결해야하는 이유를 나중에 알 수 있습니다.

    피어 및 신원

    이제 다른 조직의 피어들이 함께 모여 블록 체인 네트워크를 구성하는 방법을 보았으므로 관리자가 조직에 피어를 할당하는 방법을 이해하는 데 잠시 시간을 할애 할 가치가 있습니다.

    피어는 특정 인증 기관의 디지털 인증서를 통해 ID를 할당받습니다. X.509 디지털 인증서가이 가이드의 다른 곳에서 작동하는 방식에 대해 더 많이 읽을 수 있지만 디지털 인증서는 피어에 대한 검증 가능한 많은 정보를 제공하는 ID 카드와 같다고 생각할 수 있습니다. 네트워크의 모든 피어는 소유 조직의 관리자가 디지털 인증서를 할당받습니다 .


    피어가 채널에 연결되면 디지털 인증서는 채널 MSP를 통해 소유 조직을 식별합니다. 이 예에서 P1과 P2는 CA1이 발행 한 ID를가집니다. 채널 C는 채널 구성의 정책에서 CA1의 ID가 ORG1.MSP를 사용하여 Org1과 연관되어야한다고 결정합니다. 마찬가지로 P3과 P4는 ORG2.MSP에 의해 Org2의 일부로 식별됩니다.

    피어가 채널을 사용하여 블록 체인 네트워크에 연결할 때마다 채널 구성의 정책은 피어의 ID를 사용하여 해당 권한을 결정합니다. 조직에 대한 ID의 매핑은 멤버쉽 서비스 공급자(MSP) - 피어가 특정 조직의 특정 역할에 할당되는 방식을 결정하므로 이에 따라 블록 체인 리소스에 대한 적절한 액세스 권한이 부여됩니다. 또한 피어는 단일 조직에서만 소유 할 수 있으므로 단일 MSP와 연결됩니다. 이 항목의 뒷부분에서 피어 액세스 제어에 대해 자세히 알아보고이 가이드의 MSP 및 액세스 제어 정책에 대한 전체 항목을 제공합니다. 그러나 지금은 MSP가 블록 체인 네트워크에서 개별 신원과 특정 조직의 역할 간 연계를 제공한다고 생각하십시오.

    그리고 잠시 빗나가려면 블록 체인 네트워크와 상호 작용하는 모든 것 뿐만 아니라 피어 가 디지털 인증서와 MSP에서 조직 정체성을 획득하십시오 . 블록 체인 네트워크와 상호 작용하려는 경우 피어, 어플리케이션, 최종 사용자, 관리자, Orderer는 ID 및 관련 MSP가 있어야합니다. 신원을 사용하여 블록 체인 네트워크와 상호 작용하는 모든 엔티티 (주체)에게 이름을 제공합니다. 이 가이드의 다른 곳에서 교장 및 조직에 관해 더 많은 것을 배울 수는 있지만, 지금은 피어에 대한 이해를 계속하기에 충분합니다.

    마지막으로 피어가 실제로 위치하는 곳은 중요하지 않습니다. 클라우드 또는 조직 중 하나가 소유 한 데이터 센터 나 로컬 시스템에 상주 할 수 있습니다. 특정 조직이 소유하고 있습니다. 위의 예에서 P3은 Org1의 데이터 센터에서 호스팅 될 수 있지만 CA2와 연결된 디지털 인증서가있는 한 Org2가 소유합니다.

    피어 및 Orderer

    우리는 피어들이 피어 - 연결된 어플리케이션에 의해 질의되고 업데이트 될 수있는 원장과 체인 코드 계약을 호스팅하는 블록 체인 네트워크를 형성하는 것을 보아 왔습니다. 그러나 어플리케이션과 피어가 서로 상호 작용하여 모든 피어의 원장이 일관성을 유지하도록하는 메커니즘은 Orderer라고불리는 특수 노드에 의해 조정되며 , 이제 우리가주의를 돌리는 노드입니다.

    하나의 피어가 자체적으로 원장을 업데이트 할 수 없으므로 업데이트 트랜잭션은 쿼리 트랜잭션과 상당히 다릅니다. 이는 네트워크의 다른 피어의 동의가 필요하기 때문입니다. 피어는 네트워크의 다른 피어가 피어의 로컬 원장에 적용되기 전에 원장 업데이트를 승인해야합니다. 이 프로세스를 합의 라고 하며 쿼리보다 완료하는 데 훨씬 오래 걸립니다. 그러나 트랜잭션을 승인해야하는 모든 피어가 그렇게하고 트랜잭션이 원장에게 맡겨지면 피어는 연결된 어플리케이션에 원장이 업데이트되었음을 ​​알립니다. 이 섹션에서 피어 및 Orderer가 합의 프로세스를 관리하는 방법에 대해 자세히 자세히 설명하려고합니다.

    특히 원장을 업데이트하려는 어플리케이션은 3 단계 프로세스와 관련되어 있으므로 블록 체인 네트워크의 모든 피어가 원장을 서로 일관되게 유지할 수 있습니다. 첫 번째 단계에서 어플리케이션은 승인 된 보조 프로그램의 하위 집합과 함께 작동합니다 . 각 하위 프로그램 은 제안 된 원장 업데이트를 어플리케이션에 대한 보증으로 제공하지만 원장 사본에 제안 된 업데이트를 적용하지 않습니다. 두 번째 단계에서는 이러한 별도의 보증을 트랜잭션으로 수집하여 블록으로 패키지화합니다. 마지막 단계에서 이러한 블록은 각 트랜잭션이 확인 된 모든 피어로 다시 분산되어 해당 피어의 원장 사본에 적용됩니다.

    알 수 있듯이 Orderer 노드는이 프로세스의 핵심입니다. 따라서 어플리케이션 및 피어가 Orderer를 사용하여 분산 된 복제 원장에 일관되게 적용 할 수있는 원장 업데이트를 생성하는 방법에 대해 좀 더 자세히 살펴 보겠습니다.

    1 단계 : 제안

    트랜잭션 워크 플로우의 1 단계에는 애플리케이션과 피어 집합 간의 상호 작용이 포함됩니다. 이는 Orderer를 포함하지 않습니다. 1 단계는 제안 된 체인 코드 호출의 결과에 동의하도록 다른 조직의 승인하는 피어에게 요청하는 어플리케이션에만 관련됩니다.

    1 단계를 시작하기 위해 어플리케이션은 트랜잭션 제안서를 생성하여 필요한 피어 집합을 보냅니다. 그런 다음 각 피어는 트랜잭션 제안서 응답을 생성하기 위해 트랜잭션 제안서를 사용하여 독립적으로 체인 코드를 실행합니다. 이 업데이트는 원장에 적용되지 않지만 피어가 서명하고 어플리케이션에 반환합니다. 신청서가 충분한 수의 서명 된 제안서 응답을 받으면 트랜잭션 흐름의 첫 번째 단계가 완료됩니다. 이 단계를 조금 더 자세히 살펴 보겠습니다.


    트랜잭션 제안서는 승인 된 제안 응답을 반환하는 피어에 의해 독립적으로 실행됩니다. 이 예에서 애플리케이션 A1은 트랜잭션 T1 제안서 P를 생성하여 채널 C에서 피어 P1과 피어 P2 모두에게 전송합니다. P1은 트랜잭션 T1 제안서 P를 사용하여 S1을 실행하여 E1에서 보증하는 트랜잭션 T1 응답 R1을 생성합니다. 독립적으로 P2는 트랜잭션 T1 제안서 P를 사용하여 S1을 실행하여 E2로 보증하는 트랜잭션 T1 응답 R2를 생성합니다. 어플리케이션 A1은 트랜잭션T1에 대해 두 가지 승인 된 응답, 즉 E1과 E2를받습니다.

    처음에는 일련의 제안 된 원장 업데이트를 생성하기 위해 어플리케이션이 피어 집합을 선택합니다. 어떤 피어가 어플리케이션에서 선택합니까? 네트워크에 의해 승인되기 전에 제안 된 장부 변경을 승인해야하는 조직 집합을 정의 하는 endorsement policy (chaincode에 대해 정의 됨) 에 따라 달라집니다 . 이것은 사실상 합의를 달성한다는 것을 의미합니다. 문제가되는 모든 조직은 모든 ​​원장의 장부에 승인 되기 전에 제안 된 원장 변경을 승인해야합니다 .

    피어는 디지털 서명을 추가하고 개인 키를 사용하여 전체 페이로드에 서명함으로써 제안 응답을 보증합니다. 이 보증은 이후에이 조직의 피어가 특정 응답을 생성했음을 입증하는 데 사용될 수 있습니다. 이 예에서 피어 P1이 조직 Org1 소유이면 보증 E1은 "원장 L1의 트랜잭션 T1 응답 R1이 Org1 피어 P1에 의해 제공되었습니다!"라는 디지털 증거에 해당합니다.

    1 단계는 신청서가 충분한 피어로부터 서명 된 제안서 응답을 받으면 끝납니다. 서로 다른 피어가 동일한 트랜잭션 제안서에 대해 어플리케이션에 대해 서로 다르기 때문에 일치하지 않는 트랜잭션응답을 반환 할 수 있습니다 . 다른 국가의 원장이있는 다른 피어에게 결과가 서로 다른 시간으로 생성되었을 수도 있습니다.이 경우 어플리케이션은 단순히 최신 제안 응답을 요청할 수 있습니다. 체인 코드가  결정적이기 때문에 결과는 다를 수 있습니다.. 비 결정 성은 체인 코드 및 원장의 적이며, 발생하는 경우 일관성없는 결과가 원장에게 적용될 수 없기 때문에 제안 된 트랜잭션에 심각한 문제가 있음을 나타냅니다. 개별 피어는 트랜잭션 결과가 비 결정적이라는 것을 알 수 없습니다. 비 결정 성을 감지하기 전에 트랜잭션 응답을 함께 수집하여 비교해야합니다. 엄밀히 말하면, 이것으로도 충분하지는 않지만, 비 결정성에 대해 자세히 논의하는 트랜잭션 주제에 대해서는이 논의를 연기합니다.

    1 단계가 끝나면 어플리케이션은 일관성없는 트랜잭션 응답을 자유롭게 버리고이를 원할 경우 트랜잭션 워크 플로를 효과적으로 종료합니다. 나중에 애플리케이션이 일관성없는 트랜잭션 응답을 사용하여 원장을 업데이트하려고하면 거부 될 것입니다.

    2 단계 : 포장

    트랜잭션 워크 플로의 두 번째 단계는 패키징 단계입니다. Orderer는이 프로세스의 중추적 인 역할을합니다. 많은 애플리케이션에서 승인 된 거래 제안 응답을 포함하는 트랜잭션를받습니다. 그것은 각 트랜잭션를 다른 트랜잭션과 비교하여 순서정렬을하고, 트랜잭션의 일괄 처리를 원래의 승인하는 피어를 포함하여 Orderer에게 연결된 모든 피어에게 배포 할 준비가 된 블록으로 패키지화합니다.


    Orderer 노드의 첫 번째 역할은 제안 된 원장 갱신을 패키지하는 것입니다. 이 예에서 어플리케이션 A1은 E1 및 E2가 승인 한 트랜잭션 T1을 순서자 O1에 전송합니다. 병행하여, 어플리케이션 A2는 E1이 승인 한 트랜잭션 T2를 발주자 O1에게 전송합니다. O1은 어플리케이션 A1의 트랜잭션 T1과 어플리케이션 A2의 트랜잭션 T2를 네트워크의 다른 어플리케이션에서 다른 트랜잭션과 함께 B2 블록으로 패키지화합니다. B2에서 트랜잭션 순서는 T1, T2, T3, T4, T6, T5입니다. 이러한 트랜잭션이 Orderer 노드에 도착한 순서가 아닐 수 있습니다! (이 예제는 매우 단순화 된 Orderer 구성을 보여줍니다.)

     

    발주자는 특정 채널의 네트워크에있는 여러 어플리케이션에서 제안 된 원장 갱신을 동시에받습니다. 이 작업은 제안 된 업데이트를 잘 정의 된 순서로 정렬 하고 이후 배포를 위해 블록으로 패키지화하는 것 입니다. 이 블록은 될 것이다 블록 blockchain의! 일단 Orderer가 원하는 크기의 블록을 생성하거나 최대 경과 시간 후에 블록은 특정 채널에서 연결된 모든 피어로 전송됩니다. 이 블록이 3 단계에서 어떻게 처리되는지 살펴 보겠습니다.

    한 블록 내의 트랜잭션 순서가 Orderer에게 트랜잭션가 도착한 순서와 반드시 같지는 않다는 점은 주목할 가치가 있습니다! 트랜잭션은 블록에 임의의 순서로 패키징 할 수 있으며 실행 순서가되는 순서입니다. 중요한 것은이 때문이다  것이 아니라, 엄격한 위해 어떤 순서입니다.

    블록 내에서의 트랜잭션의 엄격한 순서정렬은은 Hyperledger Fabric을 동일한 트랜잭션을 여러 블록으로 패키징 할 수있는 다른 블록 체인과 조금 다릅니다. Hyperledger Fabric에서는 이러한 일이 발생할 수 없습니다 . 트랜잭션이 블록에 쓰여지면 장부의 위치가 확실하게 보장되기 때문에 orderer 컬렉션에 의해 생성 된 블록이 최종 이라고합니다. Hyperledger Fabric의 최종성은 원장 포크 로 알려진 비참한 사건이 발생할 수 없다는 것을 의미 합니다. 블록에서 트랜잭션을 캡처하면 추후 시점에서 해당 트랜잭션에 대한 내역을 다시 쓸 수 없습니다.

    우리는 또한 피어가 원장과 체인 코드를 호스팅하는 반면에 Orderer는 그렇지 않음을 알 수 있습니다. Orderer에게 도착한 모든 트랜잭션은 기계적으로 하나의 블록에 포장되어 있습니다. Orderer는 트랜잭션의 가치에 대해 아무런 판단도하지 않습니다. 이것은 Hyperledger Fabric의 중요한 동작입니다. 모든 트랜잭션은 엄격한 순서로 정렬되며, 트랜잭션은 삭제되거나 우선 순위가 결정됩니다.

    2 단계가 끝나면 Orderere는 제안 된 트랜잭션 업데이트를 수집하고 순서정렬하고,이를 블록으로 포장하여 배포 할 수있는 간단하지만 중요한 프로세스에 책임이 있음을 확인합니다.

    3 단계 : 유효성 검사

    트랜잭션 워크 플로의 최종 단계에는 Orderer로부터 피어에게 블록을 배포하고 이후 유효성 검사를 수행하여 장부에 적용 할 수 있습니다. 특히, 각 피어에서 블록 내의 모든 트랜잭션은 장부에 적용되기 전에 모든 관련 조직에서 일관되게 보증되도록 유효성이 검사됩니다. 실패한 트랜잭션은 감사를 위해 보관되지만 장부에 적용되지 않습니다.


    Orderer 노드의 두 번째 역할은 피어에 블록을 배포하는 것입니다. 이 예에서, 순서 Y O1은 블록 B2를 피어 P1과 피어 P2로 분 h합니다. 피어 P1은 블록 B2를 처리하여 새로운 블록이 P1의 원장 L1에 추가됩니다. 병렬 적으로 피어 P2는 블록 B2를 처리하여 새로운 블록이 P2의 원장 L1에 추가됩니다. 이 프로세스가 완료되면 원장 L1이 피어 P1 및 P2에서 일관되게 업데이트되고 각각 연결된 어플리케이션에 트랜잭션이 처리되었음을 알릴 수 있습니다.

     

    3 단계는 Orderer가 블록을 연결된 모든 피어에게 배포하는 것으로 시작됩니다. 피어는 새로운 블록이 생성되면 Orderer에게 연결된 모든 피어가 새 블록의 사본을 전송하도록 채널의 Orderer에게 연결됩니다. 각 피어는이 블록을 독립적으로 처리하지만 채널의 다른 모든 피어와 정확히 같은 방식으로 처리합니다. 이렇게하면 원장이 일관되게 유지 될 수 있습니다. 모든 피어가 발주자와 연결될 필요는 없다는 점도 주목할 가치가 있습니다. 피어는 Gassip 프로토콜을 사용하여 블록을 다른 피어에게 캐스케이드 할 수 있으며 , 이들은 또한 독자적으로 처리 할 수 ​​있습니다. 그러나 그 토론을 다른 시간에 남겨 둡시다!

    블록을 수신하면 피어는 각 트랜잭션을 블록에 나타나는 순서대로 처리합니다. 모든 트랜잭션에 대해 각 피어는 트랜잭션 을 생성 한 체인 코드 의 endorsement policy에 따라 필요한 조직이 해당 트랜잭션을 보증했는지 확인 합니다. 예를 들어, 일부 트랜잭션은 단일 조직이 보증해야하는 반면, 다른 트랜잭션은 유효한 것으로 간주되기 전에 여러 보증을 요구할 수 있습니다. 이 유효성 확인 프로세스는 모든 관련 조직이 동일한 결과 또는 결과를 생성했음을 검증합니다.

    트랜잭션이 올바르게 승인되면 피어는이를 원장에게 적용하려고 시도합니다. 이렇게하려면 피어가 원장 일관성 검사를 수행하여 제안 된 업데이트가 생성되었을 때 원장의 현재 State가 원장의 State와 호환되는지 확인해야합니다. 트랜잭션이 완전히 승인 된 경우에도 항상 가능하지는 않습니다. 예를 들어 다른 트랜잭션이 원장의 동일한 자산을 업데이트하여 트랜잭션 업데이트가 더 이상 유효하지 않아 더 이상 적용 할 수 없게 될 수 있습니다. 이러한 방식으로 각 피어의 원장 사본은 각각 동일한 유효성 검사 규칙을 따르므로 네트워크를 통해 일관되게 유지됩니다.

    피어가 각 개별 트랜잭션의 유효성을 성공적으로 검사 한 후 원장을 업데이트합니다. 실패한 트랜잭션은 원장에 적용되지 않지만 성공적인 트랜잭션과 같이 감사 목적으로 유지됩니다. 이는 피어 블록이 블록의 각 트랜잭션에서 유효하거나 유효하지 않은 표시기를 제외하고 Orderer로부터 수신 된 블록과 거의 동일 함을 의미합니다.

    3 단계에서는 체인 코드 실행이 필요하지 않습니다. 이는 1 단계에서만 수행되며 중요합니다. 즉, 체인 코드는 블록 체인 네트워크 전체가 아닌 승인 노드에서만 사용할 수 있어야합니다. 이는 체인 코드의 논리를 기밀로 유지하여 조직을지지하는 데 도움이되는 경우가 많습니다. 이는 트랜잭션을 승인했는지 여부에 상관없이 채널의 모든 피어에게 공유되는 체인 코드 (트랜잭션 제안서 응답)의 출력과 대조됩니다. 이 인증 피어링 전문가는 확장 성을 높이기 위해 설계되었습니다.

    마지막으로, 블록이 피어의 원장에게 맡길 때마다 해당 피어는 적절한 이벤트를 생성합니다 . 블록 이벤트 는 전체 블록 컨텐츠를 포함하는 반면, 블록 트랜잭션 이벤트 는 블록의 각 트랜잭션의 유효성 검증 또는 무효화 여부와 같은 요약 정보만을 포함합니다. 체인 코드 실행이 생성 한 체인 코드 이벤트도이 시점에 게시 할 수 있습니다. 어플리케이션은 이러한 이벤트 유형에 대해 등록 할 수 있으므로 이벤트 유형을 통지 할 수 있습니다. 이러한 통지는 트랜잭션 워크 플로의 세 번째이자 마지막 단계입니다.

    요약하면 3 단계는 Orderer가 원장에 일관되게 적용하여 생성 한 블록을 확인합니다. 트랜잭션을 블록으로 엄격하게 정렬하면 각 피어는 트랜잭션 업데이트가 블록 체인 네트워크 전체에 일관되게 적용되는지 확인할 수 있습니다.

    Orderer 및 합의

    이 전체 트랜잭션 워크 플로우 프로세스는 모든 피어가 Orderer가 중재하는 프로세스에서 트랜잭션의 순서 및 내용에 대한 합의에 도달했기 때문에 합의 라고 합니다. 합의는 여러 단계의 프로세스이며, 프로세스가 완료되면 어플리케이션은 원장 업데이트 만 통보됩니다. 이는 다른 피어에서 약간 다른 시간에 발생할 수 있습니다.

    우리는 향후 발주자 주제에 대해 더 자세하게 발주자에 대해 논의 할 예정이지만, 당분간은 발주자를 피어 신청서의 장부 업데이트를 수집하여 배포하여 장부에 검증하고 포함시키는 노드로 생각하십시오.

    그게 다야! 이제 Hyperledger Fabric과 관련된 피어 및 다른 구성 요소에 대한 둘러보기를 마쳤습니다. 우리는 피어들이 네트워크를 구성하고 체인 코드와 장부를 구성하고 트랜잭션 제안 및 응답을 처리하며 일관되게 트랜잭션 업데이트를 적용하여 장부를 최신 State로 유지하는 것을 여러 측면에서 가장 근본적인 요소로 인식했습니다.


    출처 : http://hyperledger-fabric.readthedocs.io/en/release-1.1/peers/peers.html

    Endorsement Policy내용

    https://stackoverflow.com/questions/48108709/what-are-members-and-admins-in-endorsement-policy-of-hyperledger-fabric

    Endorsement policies

    Endorsement Policy은 트랜잭션이 적절하게 보증되는지 여부를 결정하는 방법을 피어에게 지시하는 데 사용됩니다. 피어가 트랜잭션을 수신하면 트랜잭션 유효성 검증 플로우의 일부로 트랜잭션의 체인 코드와 연관된 VSCC (유효성 검증 시스템 체인 코드)를 호출하여 트랜잭션의 유효성을 판별합니다. 보증(endorsing)이 많은 피어로부터 하나 이상의 보증(endorsement)을 포함한다는 것을 상기하십시오. VSCC는 다음 결정을 내려야합니다 :

    • 모든 보증은 유효합니다 (즉, 예상 메시지에 대한 유효한 인증서의 유효한 서명입니다)
    • 적절한 수의 보증이 있다.
    • 보증은 예상된 소스에서 나온 것입니다.

    Endorsement Policy은 두 번째 및 세 번째 점을 지정하는 방법입니다.

    Endorsement policy syntax in the CLI

    CLI에서는 간단한 언어를 사용하여 원칙에 대한 부울 표현에 대한 정책을 표현합니다.

    principal은 서명자의 신원을 확인하고 서명자가 해당 MSP 내에서 갖는 역할을 확인하는 임무를 맡은 MSP의 관점에서 설명합니다. 구성원(member) , 관리자(admin) , 클라이언트(client) 및 피어(peer)의 네 가지 역할이 지원됩니다 . principal은 MSPROLE로 설명됩니다. 여기서 MSP는 필수 MSP의 ID이며, ROLEmemberadminclient및 peer의 네 개의 문자열 중 하나입니다. 유효한 주체의 예로는 'Org0.admin'Org0 MSP의 모든 관리자 ) 또는 'Org1.member'Org1 MSP의 모든 구성원), 'Org1.client'Org1 MSP 클라이언트 ) 및 'Org1.peer'Org1 MSP의 피어 )입니다.

    언어 구문은 다음과 같습니다. :

    EXPR(E[, E...])

    여기에서 EXPR은 두 개의 부울 표현식을 나타내는 AND 또는 OR이고 E는 principal(위에 설명 된 구문을 사용하는) 이거나 EXPR에 대한 다른 중첩 호출입니다.

    예 :
    • AND('Org1.member', 'Org2.member', 'Org3.member')는 3 명의 주체(principal) 각자에게서 1 개의 서명을 요구한다.
    • OR('Org1.member', 'Org2.member')은 두 명의 주체(principal) 중 한 명에게 1 개의 서명을 요구한다.
    • OR('Org1.member', AND('Org2.member', 'Org3.member'))Org1 MSP의 멤버로부터 하나의 서명 또는, Org2 MSP의 멤버로부터 하나의 서명을, 그리고 Org3 MSP의 멤버로부터 하나의 서명을 요청합니다.

    Specifying endorsement policies for a chaincode

    체인 코드 배포자는 이 언어를 사용하여 지정된 정책에 대해 체인 코드의 인증을 확인하도록 요청할 수 있습니다.

    Note! 인스턴스 생성시 지정되지 않은 경우 Endorsement Policy은 기본적으로 "채널에 있는 조직의 모든(any) 구성원"으로 지정됩니다. 예를 들어 'Org1' 및 'Org2'가 포함된 채널의 기본 Endorsement Policy은 'OR ('Org1.member ','Org2.member ')입니다.

    -P 스위치를 사용하여 인스턴스를 생성 할 때 정책을 지정할 수 있으며 그 뒤에 정책이 옵니다.

     :

    peer chaincode instantiate -C <channelid> -n mycc -P "AND('Org1.member', 'Org2.member')"

    이 명령은 Org1 및 Org2 구성원이 트랜잭션에 서명해야하는 AND('Org1.member', 'Org2.member') 정책으로 chaincode mycc를 배포 합니다.

    ID 분류가 활성화된 경우(Membership Service Providers (MSP) 참조) PEER 역할을 사용하여 peers에게만 보증을 제한할 수 있습니다.

     :

    peer chaincode instantiate -C <channelid> -n mycc -P "AND('Org1.peer', 'Org2.peer')"

    Note! 인스턴스 생성 후 채널에 추가된 새 조직은 체인 코드를 쿼리할 수 ​​있지만 (쿼리에 채널 정책 및 체인 코드에 의해 적용되는 모든 응용 프로그램 수준 검사가 정의한 적절한 권한을 가지고 있음에도 불구하고 체인 코드로 승인된 트랜잭션을 커밋 할 수는 없습니다). 새로운 조직의 보증을 통해 트랜잭션을 커밋 할 수 있도록 Endorsement Policy을 수정해야합니다(Upgrade and Invoke Chaincode 참조).


    출처 : http://hyperledger-fabric.readthedocs.io/en/release-1.1/endorsement-policies.html

    Upgrading from v1.0.x(v1.0.x에서 업그레이드)

    1.0.x 버전에서 패브릭 네트워크를 v1.1로 업그레이드하는 작업은 다음 단계를 수행하여 완료할 수 있습니다.

    • orderers, peers 및 fabric-ca용 바이너리를 업그레이드하십시오. 이러한 업그레이드는 병행하여 수행할 수 있습니다.
    • 클라이언트 SDK를 업그레이드하십시오.
    • v1.1 채널 기능 요구 사항을 사용합니다.
    • (선택 사항) Kafka 클러스터를 업그레이드합니다.

    이 과정을 이해하는데 도움이 되도록 Upgrading Your Network Components(네트워크 구성요소 업그레이드) 튜토리얼을 만들었습니다. 이 튜토리얼을 통해 peers, orderers 업그레이드 및 기능 요구 사항 활성화를 비롯한 대부분의 주요 업그레이드 단계를 수행 할 수 있습니다.

    이 튜토리얼은 Building Your First Network(BYFN) 샘플을 활용하기 때문에 특정 제한이 있습니다 (예 : Fabric CA는 사용하지 않습니다). 따라서 본 튜토리얼의 끝 부분에는 CA, Kafka 클러스터, CouchDB, Zookeeper, vendored chaincode shims 및 Node SDK 클라이언트를 업그레이드하는 방법이 나와 있습니다.

    기능 요구 사항에 대한 자세한 내용을 보려면 여기를 클릭 하십시오.


    출처 : http://hyperledger-fabric.readthedocs.io/en/release-1.1/upgrade_to_one_point_one.html

    Hyperledger Fabric 채널을 참고하세요.



    이 콜랙션은 다양한 v1 특징과 요소들을 다음의 것과 같은 것을 시연하는 것을 포함합니다: 원장, 채널, 가십, SDK, Chaincode, MSP 등


    출처 : http://hyperledger-fabric.readthedocs.io/en/release-1.1/videos.html

     시스템 Chaincode 플러그인

    시스템 Chaincode는 user의 Chaincode같이 분리된 Docker 컨테이너에서 실행되는 것과는 달리 피어 프로세스의 일부로 특별하게 작동하는 Chaincode입니다.

    그러므로 시스템 Chaincode는 피어의 리소스에 더 많이 접근 할 수 있고, 유저 chaincode로 실행하기 어렵거나 불가능한 특징들을 실행하는 것에 사용됩니다.

    시스템 Chaincode의 예시로는 Endorsing 제안의 ESCC(Endorser System Chaincode), 원장과 다른 fabric과 관련된 쿼리의 QSCC(Query System Chaincode) 마지막으론 커밋이 일어난 시점에 동시에 실행되는 VSCC(Validation System Chaincode)가 있습니다.

    다른 유저 Chaincode들과는 달리, 시스템 Chaincode는 SDK나 CLI의 제안을 통해서 설치되거나 인스턴스화 되지 않습니다. 피어가 시작되는 순간에 등록되고 실행됩니다.

    시스템 Chaincode가 피어와 연결되는 방법은 두가지가 있습니다.

    Go 플러그인에서 정적이거나 동적으로 연결될 수 있습니다.

    이번 튜토리얼은 시스템 Chaincode를 플러그인으로서 어떻게 개발하고 불러오는지를 배울 계획입니다.

    플러그인 개발하기

    시스템 Chaincode는 Go언어로 쓰여지고 Go 플러그인으로 불려집니다.

    플러그인은 외부의 심볼와 main 패키지를 포함하고, 아래의 커맨드로 빌드합니다.

    go build -buildmode=plugin
    

    이미 존재하는 QSCC같은 Chaincode는 접근 관리 같은 전형적으로 시스템 Chaincode를 통해 실행되는 확실한 특징을 위한 탬플릿으로 취급 받습니다.

    존재하는 시스템 Chaincode는 또한 로깅이나 테스팅 같은 최고의 예시로 참고할 수 있도록 취급받습니다.

    - 주의 사항

    임포트 된 패키지: Go 스탠다드 라이브러리는 플러그인이 반드시 호스트 어플리케이션에서 요구되는 버전과 같은 것을 포함해야합니다.

    플러그인 설정하기

    플러그인은 chaincode.systemPlugin 섹션에서 core.yaml로 설정 할 수 있습니다.

    chaincode:
      systemPlugins:
        - enabled: true
          name: mysyscc
          path: /opt/lib/syscc.so
          invokableExternal: true
          invokableCC2CC: true
    

    시스템 Chaincode는 반드시 chaincode.system 섹션에 core.yaml로 리스트가 될 수 있습니다.

    chaincode:
      system:
        mysyscc: enable
    


    출처 : http://hyperledger-fabric.readthedocs.io/en/release-1.1/systemchaincode.html

    Chaincode는 Go로 쓰여진 프로그램으로, Java와 같은 다른 프로그래밍 언어로 구현 가능합니다.  

    ChainCode는 규정된 인터페이스를 실행합니다.

    Chaincode는 Endorsing Peer Process와 격리된  안전한 Docker container에서 실행됩니다.

    어플리케이션에서 제출한 트랜잭션을 통해, Chaincode는 원장 State 초기화 및 관리를 합니다.

     

    Chaincode는 네트워크의 구성원으로부터 동의된 비즈니스 로직을 일반적으로 다루고, Smart Contract와 유사합니다.

    Chaincode는 트랜잭션 제안에 업데이트 또는 쿼리를 하기 위해서 호출될 수 있습니다.

    Chaincode에 의해 생성된 상태(state)의 범위는 해당 체인코드로 한정되며, 다른 체인코드에 의해서 직접 access할 수 없습니다.

    그러나, 동일 네트워트 상에서 적절한 권한이 주어지면 체인 코드는 다른 체인코드를 호출하여 해당 상태(state) 상태에 acess할 수 있습니다.

     

     이번 섹션에선 블록체인 네트워크 Operator 관점에서 Chaincode를 알아볼 것입니다.

    Operator 관점에선 Noah라고 불리는데, Noah의 관심점은, Chaincode의 생애주기 오퍼레이션에 중점을 둘 예정입니다;

    이는 패키징, 설치, 인스턴스화 그리고 업그레이드 같은 블록체인 내부의 Chaincode의 operational한 생애주기입니다.

    Chaincode 생애주기

    Hyperledger Fabric API는 피어, Orderer 및 MSP와 같은 블록 체인 네트워크의 다양한 노드와의 상호 작용을 가능하게 합니다.

    또한 인증 피어 노드에 Chaincode를 패키징, 설치, 인스턴스화 및 업그레이드 할 수있게 합니다. 

    Hyperledger Fabric 언어 - 특히 SDK는,  Hypercode Fabric API의 특성을 추상화하여 응용 프로그램 개발을 용이하게하지만 Chaincode의 수명주기를 관리하는 데 사용할 수 있습니다. 또한 Hyperledger 패브릭 API는 CLI를 통해 직접 액세스 할 수 있습니다.  이 문서에서는 CLI를 사용합니다.

     

    우리는 chaincode의 라이프 사이클을 관리 할 수있는 네 개의 명령 - packageinstallinstantiate, 및 upgrade 을 제공 합니다.

    향후 버전에서는 Chaincode를 실제로 제거하지 않고도 Chaincode를 비활성화하고 다시 활성화하는 트랜잭션을  stop하고 start하는 트랜잭션을 추가할 것입니다. Chaincode가 성공적으로 설치되고 인스턴스화 된 후에는 Chaincode가 활성화되어 실행 중인 invoke 트랜잭션을 통해 트랜잭션을 처리 할 수 ​​있습니다. Chaincode는 설치 후 언제든지 업그레이드 할 수 있습니다.

    패키징

    chaincode 패키지는 다음 세 부분으로 구성됩니다.

    • ChaincodeDeploymentSpec또는 CDS에 의해 정의 된 Chaincode , 
      CDS는 코드와 이름 및 버전과 같은 기타 속성의 chaincode 패키지를 정의합니다
    • • Endorsement에 사용 된 동일한 정책에 의해 구문 적으로 설명 될 수 있고 Endorsement Policy에 설명되어있는 선택적 인스턴스 정책. 그리고
    • Chaincode를 "소유하고있는"엔티티에 의한 일련의 서명.

    서명은 다음과 같은 용도로 사용됩니다.

    • Chaincode의 소유권을 확립하고,
    • 패키지의 내용을 검증 할 수 있으며,
    • 패키지 변조를 탐지 할 수 있습니다.

    채널상의 Chaincode의 인스턴스 생성 트랜잭션 생성자는 Chaincode의 인스턴스화 정책에 대해 유효성이 검사됩니다.

    패키지 만들기

    Chaincode를 패키징하는 데는 두 가지 방법이 있습니다. 하나는 Chaincode의 소유자를 여러 명 갖고 싶어하므로 여러 ID로 서명 된 chaincode 패키지가 있어야합니다. 이 작업 과정에서는 초기에 서명 된 Chaincode 패키지 (a SignedCDS)를 생성해야하며, 서명 된 Chaincode 패키지 는 연속적으로 서명을 위해 다른 각 소유자에게 전달됩니다.

    더 간단한 워크 플로우는 install 트랜잭션을 _ 행하는 노드의 ID의 서명 만 갖는 SignedCDS를 전개 할 때 사용 됩니다.

    먼저 복잡한 사례를 다룰 것입니다. 그러나 아직 여러 소유자를 걱정할 필요가없는 경우 아래 Chaincode 설치 섹션으로 건너 뛸 수 있습니다 .

    서명 된 chaincode 패키지를 만들려면 다음 명령을 사용하십시오.

    peer chaincode package -n mycc -p github.com/hyperledger/fabric/examples/chaincode/go/chaincode_example02 -v 0 -s -S -i "AND('OrgA.admin')" ccpack.out
    

    이 -s옵션은 단순히 원시 CDS를 작성하는 것이 아니라 여러 소유자가 서명 할 수있는 패키지를 작성합니다.  이때 -s가 지정되면, -S 옵션은 다른 소유자가 로그인해야 위하여려고하는 경우에 지정해야합니다. 그렇지 않으면, 프로세스는 CDS뿐만 아니라 인스턴스화 정책 만 포함하는 SignedCDS를 작성합니다.

     

    이 -S옵션은에있는 localMspid속성 의 값으로 식별되는 MSP를 사용하여 패키지에 서명하도록 프로세스에 지시합니다 core.yaml.

    이 -S옵션은 선택 사항입니다. 그러나 패키지가 서명없이 작성된 경우, signpackage명령을 사용하여 다른 소유자가 서명 할 수 없습니다 .

    선택적 -i옵션은 chaincode에 대한 인스턴스화 정책을 지정할 수있게합니다. 인스턴스화 정책은 승인 정책과 동일한 형식을 가지며 Chaincode를 인스턴스화 할 수있는 ID를 지정합니다. 위의 예에서 OrgA의 관리자 만이 chaincode를 인스턴스화 할 수 있습니다. 정책이 제공되지 않으면 기본 정책이 사용되며 피어의 MSP의 관리자 ID 만 Chaincode를 인스턴스화 할 수 있습니다.

    패키지 서명

    작성시 서명 된 Chaincode 패키지는 검사 및 서명을 위해 다른 소유자에게 양도 될 수 있습니다. 워크 플로는 Chaincode 패키지의 대역 외 서명을 지원합니다.

    ChaincodeDeploymentSpec는 선택적으로 만들기 위해 공동 소유자에 의해 서명 될 수있습니다.

    SignedChaincodeDeploymentSpec (또는 SignedCDS을). SignedCDS는 3 가지 요소를 포함합니다 :

    1. CDS에는 Chaincode의 소스 코드, 이름 및 버전이 들어 있습니다.
    2. Endorsement Policy로 표현 된 Chaincode의 인스턴스 정책.
    3. 배서의 수단으로 정의 된 Chaincode 소유자 목록 .

    노트

    이 인증 정책은 일부 채널에서 Chaincode가 인스턴스화 될 때 적절한 MSP 보안 주체를 제공하기 위해 대역 외로 결정됩니다. 인스턴스화 정책이 지정되지 않은 경우 기본 정책은 채널의 모든 MSP 관리자입니다.

    각 소유자는 ChaincodeDeploymentSpec을 해당 소유자의 신원 (예 : 인증서)과 결합하고 결합 된 결과에 서명함으로써 ChaincodeDeploymentSpec을 승인합니다.

    Chaincode 소유자는 다음 명령을 사용하여 이전에 작성한 서명 된 패키지에 서명 할 수 있습니다.

    peer chaincode signpackage ccpack.out signedccpack.out
    

    여기서 ccpack.outsignedccpack.out는 입력 및 출력 패키지입니다. signedccpack.out로컬 MSP를 사용하여 서명 된 패키지에 대한 추가 서명을 포함합니다.

    Chaincode 설치

    install 트랜잭션은 ChaincodeDeploymentSpec 또는 CDS의 형태로 정리된 포맷으로 Chaincode 소스코드를 패키징 해줍니다.

    그리고 피어 노드에 설치하고 해당 Chaincode를 실행할 것입니다.

    노트

    Chaincode를 실행할 채널의  엔드 피어 노드에 Chaincode를 설치해야합니다 .

    단순히 ChaincodeDeploymentSpec이 주어진 Install API일 때, 기본적으로 인스턴스화 정책과 빈 오너 리스트를 가지게 될 것입니다.

    노트

    Chaincode는 Chaincode 소유 구성원의 피어 노드를 승인하는 경우에만 설치해야 네트워크의 다른 구성원으로부터 Chaincode 논리의 기밀성을 보호 할 수 있습니다. Chaincode가없는 멤버는 Chaincode의 트랜잭션을 승인 할 수 없습니다. 즉, Chaincode를 실행할 수 없습니다. 그러나 이들은 여전히 ​​장부에 대한 트랜잭션의 유효성을 검사하고 커밋 할 수 있습니다.

    Chaincode를 설치하기 위해선, SignedProposal을 시스템 Chaincode 섹션에서 설명된 lifecycle system chaincode를 전송하십시오.

    예를 들어, CLI를 사용하여 Simple Asset Chaincode 섹션에 설명 된 sacc 샘플 체인 코드 를 설치하려면 명령이 다음과 같아야합니다.

    peer chaincode install -n asset_mgmt -v 1.0 -p sacc
    

    CLI는 내부적으로 sacc에 SignedChaincodeDeploySpec을 만들고, 로컬 피어에 전송합니다. 이는 LSCC에서 install 메소드로 불립니다.

    인자 -p는 chaincode의 경로를 의미하고, 유저의 GOPATH에 있어야합니다.(예:GOPATH/src/sacc) CLI 섹션을 확인하시면 커맨드 옵션에 완벽한 설명이 되어 있습니다.

    피어에 설치하기 위해선, SignedProposal의 서명이 로컬 MSP 관리자 중 하나여야만 합니다.

    인스턴스화

    instantiate 트랜잭션이 호출 (LSCC)를 작성하고 채널에 chaincode를 초기화 할 수 있습니다. 이것은 Chaincode 채널 바인딩 프로세스입니다. Chaincode는 여러 채널에 바인딩되어 각 채널에서 개별적으로 독립적으로 작동 할 수 있습니다. 즉, Chaincode를 설치하고 인스턴스화 할 수있는 다른 채널 수에 관계없이 State는 트랜잭션이 제출 된 채널과 격리되어 있습니다.lifecycle System Chaincode

    instantiate 트랜잭션 생성자는 SignedCDS에 포함 된 Chaincode의 인스턴스화 정책을 충족해야하며 채널 작성자로 채널 작성자로 구성되어야합니다. 채널의 보안이 악성 엔티티가 Chaincode를 배포하거나 구성원을 속여 언 바운드 채널에서 Chaincode를 실행하는 것을 방지하는 데 중요합니다.

    예를 들어 기본 인스턴스화 정책은 모든 채널 MSP 관리자이므로 Chaincode 인스턴스 생성 트랜잭션 작성자는 채널 관리자의 구성원이어야합니다. 트랜잭션 제안서가 엔도 서에 도착하면 생성자의 서명을 인스턴스화 정책과 비교하여 검증합니다. 이 작업은 장부에 커밋하기 전에 트랜잭션 유효성 검사 중에 다시 수행됩니다.

    또한 인스턴스 생성 트랜잭션은 채널에서 해당 Chaincode에 대한 Endorsement Policy를 설정합니다. Endorsement Policy는 채널 구성원이 승인 한 트랜잭션 결과에 대한 증명 요구 사항을 설명합니다.

    예를 들어, 인스턴스화 CLI를 사용하여 SACC chaincode와 함께 State를 john과 0으로 초기화하고, 명령은 다음과 같습니다

    peer chaincode instantiate -n sacc -v 1.0 -c '{"Args":["john","0"]}' -P "OR ('Org1.member','Org2.member')"
    

    노트

    Endorsement Policy에 유의하십시오 .이 경우 모든 트랜잭션이 sacc 할 수 있도록 Org1 또는 Org2 구성원의 Endorsement가 필요합니다 . 즉, Org1 또는 Org2는 유효한 트랜잭션이되도록 sacc 에서  를 실행 한 결과에 서명해야 합니다.

    성공적으로 인스턴스화 된 후에는 Chaincode가 채널의 활성 State가되며 ENDORSER_TRANSACTION 유형의 모든 트랜잭션 제안을 처리 할 준비가됩니다 . 트랜잭션은 Endorsement 피어에 도착하면서 동시에 처리됩니다.

    업그레이드

    체인 코드는 SignedCDS의 일부 버전을 변경하여 언제든지 업그레이드 할 수 있습니다. 소유자 및 인스턴스 정책과 같은 다른 부분은 선택 사항입니다. 그러나 체인 코드 이름은 동일해야합니다. 그렇지 않으면 완전히 다른 체인 코드로 간주됩니다.

    업그레이드하기 전에 새 버전의 체인 코드를 필요한 endorser에 설치해야합니다. 업그레이드는 체인 코드의 새 버전을 채널에 바인드하는 인스턴스화 트랜잭션과 유사한 트랜잭션입니다. 체인 코드의 이전 버전에 바인딩 된 다른 채널은 여전히 ​​이전 버전과 함께 실행됩니다. 즉, upgrade트랜잭션은 한 번에 하나의 채널 (트랜잭션이 제출되는 채널)에만 영향을줍니다.

    노트

    체인 코드의 여러 버전이 동시에 활성화 될 수 있으므로 업그레이드 프로세스가 자동으로 이전 버전을 제거하지 않으므로 사용자는 당분간이를 관리해야합니다.

    instantiate트랜잭션 과의 미묘한 차이점이 있습니다. upgrade트랜잭션은 새 정책 (지정된 경우)이 아닌 현재 체인 코드 인스턴스화 정책에 대해 검사됩니다. 이것은 현재 인스턴스화 정책에 지정된 기존 구성원 만이 체인 코드를 업그레이드 할 수 있도록하기위한 것입니다.

    노트

    업그레이드 중에 chaincode Init함수가 호출되어 데이터 관련 업데이트를 수행하거나 다시 초기화하므로 체인 코드를 업그레이드 할 때 State를 다시 설정하지 않도록주의해야합니다.

    중지 및 시작

    stopstart라이프 사이클 트랜잭션은 아직 구현되지 않았습니다. 그러나 각 endorsers에서 chaincode 컨테이너와 SignedCDS 패키지를 제거하여 체인 코드를 수동으로 중지 할 수 있습니다.  이것은 인증 피어 노드가 실행중인 각 호스트 또는 가상 시스템에서 체인 코드의 컨테이너를 삭제 한 다음 각 인증 피어 노드에서 SignedCDS를 삭제하여 수행됩니다.

    참고 : 피어 노드에서 CDS를 삭제하려면 먼저 피어 노드의 컨테이너에 들어가야합니다. 이를 수행 할 수있는 유틸리티 스크립트를 제공해야합니다.
    docker rm -f <container id>
    rm /var/hyperledger/production/chaincodes/<ccname>:<ccversion>

    Stop은 업그레이드를하기 전에 모든 피어의 채널에서 체인 코드를 중지 할 수있는 제어 된 방식으로 업그레이드를 수행하는 워크 플로에서 유용합니다.

    CLI

     참고 : 우리는 Hyperledger Fabric 바이너리 용 플랫폼 특정 peer 바이너리를 배포 할 필요성을 평가하고 있습니다. 당분간, 실행중인 도커 컨테이너에서 명령을 간단히 호출 할 수 있습니다.

    현재 사용 가능한 CLI 명령을 보려면 실행중인 fabric-peerDocker 컨테이너 에서 다음 명령을 실행하십시오 .

    docker run -it hyperledger/fabric-peer bash 
    # peer chaincode --help

    아래 예제와 비슷한 출력을 보여줍니다 :

    Usage:
      peer chaincode [command]
    
    Available Commands:
      install     Package the specified chaincode into a deployment spec and save it on the peer's path.
      instantiate Deploy the specified chaincode to the network.
      invoke      Invoke the specified chaincode.
      list        Get the instantiated chaincodes on a channel or installed chaincodes on a peer.
      package     Package the specified chaincode into a deployment spec.
      query       Query using the specified chaincode.
      signpackage Sign the specified chaincode package
      upgrade     Upgrade chaincode.
    
    Flags:
          --cafile string      Path to file containing PEM-encoded trusted certificate(s) for the ordering endpoint
      -h, --help               help for chaincode
      -o, --orderer string     Ordering service endpoint
          --tls                Use TLS when communicating with the orderer endpoint
          --transient string   Transient map of arguments in JSON encoding
    
    Global Flags:
          --logging-level string       Default logging level and overrides, see core.yaml for full syntax
          --test.coverprofile string   Done (default "coverage.cov")
      -v, --version
    
    Use "peer chaincode [command] --help" for more information about a command.

    스크립트 응용 프로그램에서의 사용을 용이하게하기 위해 peer명령은 명령 실패시 항상 0이 아닌 리턴 코드를 생성합니다.

    체인 코드 명령의 예 :

    peer chaincode install -n mycc -v 0 -p path/to/my/chaincode/v0
    peer chaincode instantiate -n mycc -v 0 -c '{"Args":["a", "b", "c"]}' -C mychannel
    peer chaincode install -n mycc -v 1 -p path/to/my/chaincode/v1
    peer chaincode upgrade -n mycc -v 1 -c '{"Args":["d", "e", "f"]}' -C mychannel
    peer chaincode query -C mychannel -n mycc -c '{"Args":["query","e"]}'
    peer chaincode invoke -o orderer.example.com:7050  --tls --cafile $ORDERER_CA -C mychannel -n mycc -c '{"Args":["invoke","a","b","10"]}'

    시스템 체인 코드

    시스템 체인 코드는 일반적인 체인 코드와 같은 격리 된 컨테이너가 아닌 피어 프로세스 내에서 실행된다는 점을 제외하고는 동일한 프로그래밍 모델을 사용합니다. 따라서 시스템 체인 코드는 피어 실행 파일에 내장되어 있으며 위에서 설명한 동일한 수명주기를 따르지 않습니다. 특히 설치 , 인스턴스화 및 업그레이드 는 시스템 체인 코드에 적용되지 않습니다.

    시스템 체인 코드의 목적은 피어와 체인 코드 간 gRPC 통신 비용을 단축하고 관리 유연성을 절충하는 것입니다. 예를 들어, 시스템 체인 코드는 피어 이진 파일로만 업그레이드 할 수 있습니다. 또한 컴파일 된 매개 변수 의 고정 세트로 등록해야하며 Endorsement Policy 또는 Endorsement Policy 기능이 없습니다.

    시스템 체인 코드는 Hyperbridger Fabric에서 시스템 통합 자에 의해 적절하게 대체되거나 수정 될 수 있도록 여러 시스템 동작을 구현하는 데 사용됩니다.

    시스템 체인 코드의 현재 목록 :

    1. LSCC Lifecycle 시스템 체인 코드는 위에서 설명한 라이프 사이클 요청을 처리합니다.
    2. CSCC 구성 시스템 체인 코드는 피어 측의 채널 구성을 처리합니다.
    3. QSCC 쿼리 시스템 체인 코드는 블록 및 트랜잭션 가져 오기와 같은 원장 쿼리 API를 제공합니다.
    4. ESCC 인증 시스템 체인 코드는 트랜잭션 제안 제안서에 서명함으로써 Endorsement를 처리합니다.
    5. VSCC 유효성 검사 시스템 체인 코드는 Endorsement Policy 및 다중 버전 동시성 제어 검사와 같은 트랜잭션 유효성 검사를 처리합니다.

    이러한 시스템 체인 코드, 특히 LSCC, ESCC 및 VSCC가 주 트랜잭션 실행 경로에 있으므로 수정 또는 교체 할 때는주의해야합니다. 

    VSCC가 장부에 커밋하기 전에 블록의 유효성을 검사 할 때 채널의 모든 피어가 원장 분기 (비 결정 성)를 피하기 위해 동일한 유효성 검사를 계산하는 것이 중요합니다. 

    따라서 VSCC가 수정되거나 대체 된 경우 특별한 주의가 필요합니다.


    출처 : http://hyperledger-fabric.readthedocs.io/en/release-1.1/chaincode4noah.html

    Chaincode는 Go와 Node.js로 쓰여진 프로그램입니다. 그리고 규정된 인터페이스를 실행합니다.

    차후엔 자바와 같은 다른 프로그래밍 언어들도 지원할 것입니다.

    Chaincode는 보안된 Docker container에 허가된 피어 프로세스와 격리되어 실행됩니다.

    Chaincode는 어플리케이션에서 제출하여 트랜잭션으로 원장 State 초기화 및 관리를 합니다.

    Chaincode는 전형적으로 네트워크의 구성원으로부터 동의된 비즈니스 로직을 다루고, 그래서 Smart Contract와 유사합니다.

    Chaincode는 트랜잭션 제안에 업데이트 또는 쿼리를 하기 위해서 호출될 수 있습니다.

    허가를 받은 State에서, Chaincode는 state에 액세스 하기 위해서 같은 Channel이나 다른 Channel에서도 또 다른 Chaincode를 호출할 수 있습니다.

    만약 다른 Channel에서 호출된 Chaincode일 경우 읽기 전용으로만 접근이 가능하다는 점을 알고 계셔야합니다.

    즉, 다른 Channel에서 불려진 Chaincode는 단지 쿼리일 뿐이라는 것을 의미합니다. 이는 이후의 커밋 페이즈에서 State 인증에 참여하지 않는다는 것을 의미하고 있습니다.

    다음의 섹션에선, 어플리케이션 개발자의 입장에서 Chaincode를 배워볼 것 입니다.

    단순한 어플리케이션의 샘플 코드와 Chaincode Shim API의 각각의 메소드의 목적을 확인하는 것을 보여드리겠습니다.

    Chaincode API

    각각의 Chaincode 프로그램은 아래의 Chaincode interface로 실행되어야합니다:

    • Go
    • Node.js

    해당 인터페이스들의 전달받은 트랜잭션의 반응으로 메소드 콜을 발생시킵니다.

    특히 Init 메소드는 Chaincode가 Instantiate나 Upgrade와 같은 트랜잭션 메소드를 어플리케이션 State에 관한 초기화를 포함하여 Chaincode가 필요한 초기화를 위해서 불려집니다.

    Invoke 메소드는 Invoke 트랜잭션이 트랜잭션의 제안을 받았을 때 발생하게 됩니다.

    다른 "Shim" API에 들어있는 Chaincode는 ChaincodeStubInterface 아래의 언어로 실행됩니다:

    • Go
    • Node.js

    이들은 원장에 접근하거나 수정하기위해서 사용되고, Chaincode 간에 호출을 위해서 사용됩니다.

    이번 튜토리얼에선, 단순한 "Asset"을 관리하는 Chaincode 어플리케이션을 실행함으로서 이러한 종류의 API 사용을 시연하겠습니다.

    Simple Asset Chaincode

    아래의 어플리케이션은 원장에 Asset을 Key-Value 페어로 만드는 간단한 샘플 Chaincode 입니다.

    code의 디렉토리 설정하기

    Go언어로 개발한 경험이 없으시다면, Go언어가 시스템에 적절하게 설정된 State로 설치되어 있어야 합니다.

    지금부터, Chaincode 어플리케이션을 위한 하나의 child directory로서 $GOPATH/src/ 디렉토리를 만들겠습니다.

    간단히 실행하기 위해선, 아래의 커맨드를 입력하세요.

    mkdir -p $GOPATH/src/sacc && cd $GOPATH/src/sacc
    

    코드를 써넣을 소스 코드를 만들어 보겠습니다.

    touch sacc.go
    

    시스템 하우스 관리

    우선, 하우스 관리를 하면서 시작합시다. 모든 Chaincode들 처럼, Chaincode 인터페이스를 실행해주어야 합니다.

    특히, Init과 Invoke 함수를 실행하셔야 합니다.

    go언어에 Chaincode 의존성을 추가하십시오.

    Chaincode shim package와 peer protobuf package를 임포트 할 것입니다.

    다음으로, Simple Asset을 Chaincode Shim Function으로서 추가할 것 입니다.

    package main
    
    import (
        "fmt"
    
        "github.com/hyperledger/fabric/core/chaincode/shim"
        "github.com/hyperledger/fabric/protos/peer"
    )
    
    // SimpleAsset implements a simple chaincode to manage an asset
    type SimpleAsset struct {
    }
    

    Chaincode 초기화

    다음으로, Init 함수를 실행할 것입니다.

    // Init is called during chaincode instantiation to initialize any data.
    func (t *SimpleAsset) Init(stub shim.ChaincodeStubInterface) peer.Response {
    
    }
    

    해당 함수에서 이미 Chaincode 업그레이드가 이루어진다는 것을 확인하세요.

    Chaincode를 작성할 때 이전의 것을 업그레이드 할 것입니다.

    Init을 적절하게 수정하셔야합니다.

    특히, "마이그레이션"이 없으면 아무 것도 초기화 되지 않고, 비어있는 Init 메소드를 제공합니다.

    다음으로, Init 호출에서 ChaincodeStubInterface.GetStringArgs 메소드를 통해 매개변수를 돌려받습니다. 그리고 유효성을 체크합니다.

    우리의 경우에, Key-Value 쌍을 기대할 수 있습니다.

    // Init is called during chaincode instantiation to initialize any
    // data. Note that chaincode upgrade also calls this function to reset
    // or to migrate data, so be careful to avoid a scenario where you
    // inadvertently clobber your ledger's data!
    func (t *SimpleAsset) Init(stub shim.ChaincodeStubInterface) peer.Response {
      // Get the args from the transaction proposal
      args := stub.GetStringArgs()
      if len(args) != 2 {
        return shim.Error("Incorrect arguments. Expecting a key and a value")
      }
    }
    

    다음 단계는, 호출이 유효할 수 있도록 만들어 냈습니다, 이제 원장에 초기 State를 저장할 것입니다.

    이 단계를 진행하기에 앞서, ChaincodeStubInterface.Putstate를 불러내어 Key와 Value를 인자로 전송할 것 입니다.

    모든 것이 잘 되었다는 전제하에, 초기화 하는 Response 객체가 성공했을 것입니다.

     1 // Init is called during chaincode instantiation to initialize any
     2 // data. Note that chaincode upgrade also calls this function to reset
     3 // or to migrate data, so be careful to avoid a scenario where you
     4 // inadvertently clobber your ledger's data!
     5 func (t *SimpleAsset) Init(stub shim.ChaincodeStubInterface) peer.Response {
     6   // Get the args from the transaction proposal
     7   args := stub.GetStringArgs()
     8   if len(args) != 2 {
     9     return shim.Error("Incorrect arguments. Expecting a key and a value")
    10   }
    11 
    12   // Set up any variables or assets here by calling stub.PutState()
    13 
    14   // We store the key and the value on the ledger
    15   err := stub.PutState(args[0], []byte(args[1]))
    16   if err != nil {
    17     return shim.Error(fmt.Sprintf("Failed to create asset: %s", args[0]))
    18   }
    19   return shim.Success(nil)
    20 }
    

    Chaincode 호출

    우선, Invoke 함수의 서명을 추가합니다.

    // Invoke is called per transaction on the chaincode. Each transaction is
    // either a 'get' or a 'set' on the asset created by Init function. The 'set'
    // method may create a new asset by specifying a new key-value pair.
    func (t *SimpleAsset) Invoke(stub shim.ChaincodeStubInterface) peer.Response {
    
    }
    

    위에서의 Invoke 함수와 함께, ChaincodeStubInterface로부터 인자를 추출해낼 필요가 있습니다.

    Invoke 함수의 인자는 호출할 Chaincode 어플리케이션의 함수 이름입니다.

    우리의 경우에, 간단히 두 가지의 함수를 가지고 있습니다: set & get

    해당 함수들을 통해서 asset의 값을 set할 수 있고, 또한 현재 State를 리턴 받을 수 있습니다.

    우리는 우선 ChaincodeStrubInterface.GetFunctionAndParameters를 함수의 이름과 매개변수를 chaincode 어플리케이션 함수에 추출하기 위해서 호출 할 것입니다.

    // Invoke is called per transaction on the chaincode. Each transaction is
    // either a 'get' or a 'set' on the asset created by Init function. The Set
    // method may create a new asset by specifying a new key-value pair.
    func (t *SimpleAsset) Invoke(stub shim.ChaincodeStubInterface) peer.Response {
        // Extract the function and args from the transaction proposal
        fn, args := stub.GetFunctionAndParameters()
    
    }
    

    다음으로, 우리는 함수의 이름을 set과 get과 같은 형태로 만들어 낼 것입니다. 그리고 해당되는 Chaincode 어플리케이션 함수를 적절한 Shim.success와 Shim.error 함수를 gRPC protobuf 메시지 형태로 응답하며 시리얼라이즈 출력을 하면서 호출해낼 것 입니다.

    // Invoke is called per transaction on the chaincode. Each transaction is
    // either a 'get' or a 'set' on the asset created by Init function. The Set
    // method may create a new asset by specifying a new key-value pair.
    func (t *SimpleAsset) Invoke(stub shim.ChaincodeStubInterface) peer.Response {
        // Extract the function and args from the transaction proposal
        fn, args := stub.GetFunctionAndParameters()
    
        var result string
        var err error
        if fn == "set" {
                result, err = set(stub, args)
        } else {
                result, err = get(stub, args)
        }
        if err != nil {
                return shim.Error(err.Error())
        }
    
        // Return the result as success payload
        return shim.Success([]byte(result))
    }
    

    Chaincode 어플리케이션 실행하기

    씌여진 대로, 우리의 Invoke 함수를 통해서 두개의 함수를 가진 Chaincode 어플리케이션을 실행할 것입니다.

    이제 해당하는 함수들을 실행합니다. 위에서 말한 것처럼, 원장에 접근하기 위해선, ChaincodeStubInterface.Putstate와 ChaincodeStubInterface.Getstate 함수를 Chaincode shim API로부터 불러들일 것 입니다.

    // Set stores the asset (both key and value) on the ledger. If the key exists,
    // it will override the value with the new one
    func set(stub shim.ChaincodeStubInterface, args []string) (string, error) {
        if len(args) != 2 {
                return "", fmt.Errorf("Incorrect arguments. Expecting a key and a value")
        }
    
        err := stub.PutState(args[0], []byte(args[1]))
        if err != nil {
                return "", fmt.Errorf("Failed to set asset: %s", args[0])
        }
        return args[1], nil
    }
    
    // Get returns the value of the specified asset key
    func get(stub shim.ChaincodeStubInterface, args []string) (string, error) {
        if len(args) != 1 {
                return "", fmt.Errorf("Incorrect arguments. Expecting a key")
        }
    
        value, err := stub.GetState(args[0])
        if err != nil {
                return "", fmt.Errorf("Failed to get asset: %s with error: %s", args[0], err)
        }
        if value == nil {
                return "", fmt.Errorf("Asset not found: %s", args[0])
        }
        return string(value), nil
    }
    

    모든 값을 가져오기

    마지막으로 main 함수를 추가해야할 필요가 있습니다. 이 함수는 shim.start 함수를 불러낼 것입니다.

    이제 전체 Chaincode 소스코드를 보여드리겠습니다.

    package main
    
    import (
        "fmt"
    
        "github.com/hyperledger/fabric/core/chaincode/shim"
        "github.com/hyperledger/fabric/protos/peer"
    )
    
    // SimpleAsset implements a simple chaincode to manage an asset
    type SimpleAsset struct {
    }
    
    // Init is called during chaincode instantiation to initialize any
    // data. Note that chaincode upgrade also calls this function to reset
    // or to migrate data.
    func (t *SimpleAsset) Init(stub shim.ChaincodeStubInterface) peer.Response {
        // Get the args from the transaction proposal
        args := stub.GetStringArgs()
        if len(args) != 2 {
                return shim.Error("Incorrect arguments. Expecting a key and a value")
        }
    
        // Set up any variables or assets here by calling stub.PutState()
    
        // We store the key and the value on the ledger
        err := stub.PutState(args[0], []byte(args[1]))
        if err != nil {
                return shim.Error(fmt.Sprintf("Failed to create asset: %s", args[0]))
        }
        return shim.Success(nil)
    }
    
    // Invoke is called per transaction on the chaincode. Each transaction is
    // either a 'get' or a 'set' on the asset created by Init function. The Set
    // method may create a new asset by specifying a new key-value pair.
    func (t *SimpleAsset) Invoke(stub shim.ChaincodeStubInterface) peer.Response {
        // Extract the function and args from the transaction proposal
        fn, args := stub.GetFunctionAndParameters()
    
        var result string
        var err error
        if fn == "set" {
                result, err = set(stub, args)
        } else { // assume 'get' even if fn is nil
                result, err = get(stub, args)
        }
        if err != nil {
                return shim.Error(err.Error())
        }
    
        // Return the result as success payload
        return shim.Success([]byte(result))
    }
    
    // Set stores the asset (both key and value) on the ledger. If the key exists,
    // it will override the value with the new one
    func set(stub shim.ChaincodeStubInterface, args []string) (string, error) {
        if len(args) != 2 {
                return "", fmt.Errorf("Incorrect arguments. Expecting a key and a value")
        }
    
        err := stub.PutState(args[0], []byte(args[1]))
        if err != nil {
                return "", fmt.Errorf("Failed to set asset: %s", args[0])
        }
        return args[1], nil
    }
    
    // Get returns the value of the specified asset key
    func get(stub shim.ChaincodeStubInterface, args []string) (string, error) {
        if len(args) != 1 {
                return "", fmt.Errorf("Incorrect arguments. Expecting a key")
        }
    
        value, err := stub.GetState(args[0])
        if err != nil {
                return "", fmt.Errorf("Failed to get asset: %s with error: %s", args[0], err)
        }
        if value == nil {
                return "", fmt.Errorf("Asset not found: %s", args[0])
        }
        return string(value), nil
    }
    
    // main function starts up the chaincode in the container during instantiate
    func main() {
        if err := shim.Start(new(SimpleAsset)); err != nil {
                fmt.Printf("Error starting SimpleAsset chaincode: %s", err)
        }
    }
    

    Chaincode 만들기

    Chaincode를 컴파일 하겠습니다.

    go get -u --tags nopkcs11 github.com/hyperledger/fabric/core/chaincode/shim
    go build --tags nopkcs11
    

    오류가 없다는 전제하에, Chaincode를 테스팅 하는 다음단계로 나아가실 수 있습니다.

    개발자 모드로 테스팅하기

    일반적으로 Chaincode는 피어에 의해서 시작되고 관리됩니다. 그러나 개발자 모드에선 Chaincode는 사용자에 의해서 만들어지고 제작됩니다.

    이 모드는 개발 도중 빠른 코딩/빌드/실행/디버그 사이클을 돌려보는 것에 매우 유용합니다.

    우리는 샘플 개발자 네트워크에서 이미 만들어진 Orderer와 채널 아티팩트를 사용해서 개발자 모드를 시작할 것입니다.

    마찬가지로, 사용자는 바로 Chaincode를 컴파일 하고 실행해보실 수 있습니다.

    Hyperledger Fabric Sample 설치하기

    앞의 과정이 문제없이 해결되셨다면, Hyperledger Sample을 설치하십시오.

    Docker의 chaincode-docker-devmode 디렉토리의 fabric-samples를 복사하십시오.

    cd chaincode-docker-devmode
    

    Docker 이미지 다운로드 하기

    개발자 모드를 위해선 제공된 Docker Compose 스크립트를 이용해서 4개의 Docker 이미지를 활용해야 합니다.

    만약 fabric-samples 디렉토리에 복사본을 설치하셨다면 DownloadPlatform-specific Binaies의 지시를 따르시면 됩니다.

    그러면, 로컬에 설치된 Docker 이미지를 가질 수 있습니다.

    만약 수동으로 받아온 이미지라면 latest를 붙이셔야만 합니다.

    docker images
    REPOSITORY                     TAG                                  IMAGE ID            CREATED             SIZE
    hyperledger/fabric-tools       latest                           b7bfddf508bc        About an hour ago   1.46GB
    hyperledger/fabric-tools       x86_64-1.1.0                     b7bfddf508bc        About an hour ago   1.46GB
    hyperledger/fabric-orderer     latest                           ce0c810df36a        About an hour ago   180MB
    hyperledger/fabric-orderer     x86_64-1.1.0                     ce0c810df36a        About an hour ago   180MB
    hyperledger/fabric-peer        latest                           b023f9be0771        About an hour ago   187MB
    hyperledger/fabric-peer        x86_64-1.1.0                     b023f9be0771        About an hour ago   187MB
    hyperledger/fabric-javaenv     latest                           82098abb1a17        About an hour ago   1.52GB
    hyperledger/fabric-javaenv     x86_64-1.1.0                     82098abb1a17        About an hour ago   1.52GB
    hyperledger/fabric-ccenv       latest                           c8b4909d8d46        About an hour ago   1.39GB
    hyperledger/fabric-ccenv       x86_64-1.1.0                     c8b4909d8d46        About an hour ago   1.39GB
    

    docker image를 발급해서 로컬 Docker Registry에 올리십시오. 아래와 같은 것을 확인하실 수 있을 것입니다.

    이제 3개의 터미널을 열어 chaincode-docker-devmode 디렉토리로 모든 터미널을 이동해주십시오.

    터미널1 네트워크 시작하기

    docker-compose -f docker-compose-simple.yaml up
    

    위의 커맨드는 singleSampleMSPSolo의 Orderer 정보와 함께 네트워크를 시작합니다.

    그리고 피어를 개발자 모드로 실행합니다.

    남은 두개의 컨테이너는 chaincode 환경과 CLI 환경을 위한 것입니다.

    채널을 만들고 참여하기 위한 기능들은 CLI환경에서 제공합니다.

    그렇기 때문에 바로 Chaincode 호출로 넘어갈 수 있습니다.

    터미널2 빌드& 스타트 Chaincode

    docker exec -it chaincode bash
    

    입력하신 이후 아래와 같은 결과를 보실 수 있습니다.

    root@d2629980e76b:/opt/gopath/src/chaincode#
    

    Chaincode를 컴파일 하십시오.

    cd sacc
    go build
    

    Chaincode를 실행하세요.

    CORE_PEER_ADDRESS=peer:7052 CORE_CHAINCODE_ID_NAME=mycc:0 ./sacc
    

    Chaincode가 피어와 함께 실행되었고, Chaincode 로그는 성공적인 등록을 피어와 마쳤을 것입니다.

    이 단계에서 Chaincode가 어떤 채널과도 연관되지 않았다는 것을 아셔야합니다.

    이 과정은 다음에 나올 Instantiate 커맨드에서 완료하실 수 있습니다.

    터미널3 Chaincode 사용하기

    비록 --peer-chaincodedev모드에 있더라도, Chaincode를 설치하셔야 chaincode 라이프 싸이클을 정상적으로 확인할 수 있습니다.

    이 요구사항은 앞으로 사라질 예정입니다.

    CLI 컨테이너에서 아래와 같은 명령으로 불러낼 수 있습니다.

    docker exec -it cli bash
    
    peer chaincode install -p chaincodedev/chaincode/sacc -n mycc -v 0
    peer chaincode instantiate -n mycc -v 0 -c '{"Args":["a","10"]}' -C myc
    

    이제 a 값에 20을 할당하세요.

    peer chaincode invoke -n mycc -c '{"Args":["set", "a", "20"]}' -C myc
    

    마지막으로 쿼리 a를 실행하시고, 20이라는 값을 확인하세요

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

    새로운 Chaincode 테스팅하기

    기본적으로, 여러분은 sacc만 마운팅하셨을 겁니다. 그러나 chaincode(chaincode 컨테이너를 의미함)에 다른 chaincode를 올림으로서 테스트해보실 수 있습니다.

    이 지점 이후로 Chaincode 컨테이너로 접근 가능하실 것 입니다.

    Chaincode 암호화

    특정 시나리오에서는 전체 또는 부분적으로 키와 연관된 값을 암호화하는 것이 유용 할 수 있습니다. 예를 들어 개인의 주민등록번호 또는 주소가 원장에게 쓰여진 경우에 데이터가 일반 텍스트로 나타나지 않게 할 수 있습니다. 시리얼 코드 암호화는 상품 공장과 BCCSP wrapper 와 엔티티 확장을 활용하여 암호화 및 타원 곡선형 디지털 서명과 같은 암호화 작업을 수행함으로써 수행됩니다. 예를 들어 암호화하려면 chaincode의 호출자가 transient 필드를 통해 암호화 키를 전달합니다. 그러면 동일한 키가 후속 쿼리 작업에 사용되어 암호화 된 State 값을 적절히 해독 할 수 있습니다.

    자세한 정보 및 샘플 은 디렉토리 내의 Encc 예제를 참조하십시오 fabric/examplesutils.go 도우미 프로그램을 확인해보십시오. 이 유틸리티는 chaincode shim API 및 Entities 확장을 로드하고 샘플 암호화 체인 코드가 활용 하는 새로운 클래스의 기능 (예 encryptAndPutStategetStateAndDecrypt)을 빌드합니다 . 따라서 체인 코드는 및 추가 된 기능 Get과 Put 함께 추가된 기능인 Encrypt와 Decript를 포함해서 기본 shim API와 결합 할 수 있습니다.

    Go언어로 씌여진 Chaincode의 외부 의존성 관리

    여러분의 Chaincode가 Go에서 제공하는 라이브러리에서 제공하는 패키지가 아닌 다른 패키지를 요구할 경우에, Chaincode에 패키지를 포함하실 수 있습니다.

    이러한 의존성을 관리하거나 배포할 수 있는 다양한 툴이 있습니다.

    governor라는 라이브러리를 이용해서 시연을 하겠습니다.

    govendor init
    govendor add +external  // Add all external package, or
    govendor add github.com/external/pkg // Add specific external package
    

    이렇게 임포트한 외부 의존성 파일은 vendor 디렉토리에 보관됩니다. peer chaincode package와 peer chaincode install과 같은 명령어는 Chaincode 패키지에 의존성과 관련된 코드를 포함합니다.


    출처 : http://hyperledger-fabric.readthedocs.io/en/release-1.1/chaincode4ade.html

    + Recent posts