🥇Blockchain: wat PoC solle mir bauen?

Deng Ae fäerten an d'Hänn jucken!

A fréieren Artikelen hu mir d'Technologien beschäftegt op deenen Blockchaine gebaut ginn (Wat solle mir e Blockchain bauen?) a Fäll déi mat hirer Hëllef ëmgesat kënne ginn (Firwat solle mir e Fall bauen?). Et ass Zäit mat Ären Hänn ze schaffen! Fir Piloten a PoC (Proof of Concept) ëmzesetzen, benotzen ech léiwer d'Wolleken, well ... Si kënne vun iwwerall op der Welt zougänglech sinn an dacks ass et net néideg Zäit op langweileg Installatioun vun der Ëmwelt ze verschwenden, well Et gi preset Konfiguratiounen. Also, loosst eis eppes einfach maachen, zum Beispill e Netzwierk fir Mënzen tëscht Participanten ze transferéieren a loosst eis et bescheiden Bitcoin nennen. Fir dëst benotze mir d'IBM Cloud an den universellen Blockchain Hyperledger Fabric. Als éischt, loosst eis erausfannen firwat Hyperledger Fabric en Universal Blockchain genannt gëtt?

Hyperledger Stoff - eng universell Blockchain

Allgemeng ass en universellen Informatiounssystem:

Eng Rei vu Serveren an e Softwarekär deen d'Geschäftslogik ausféiert;
Interfaces fir Interaktioun mam System;
Tools fir Aschreiwung, Authentifikatioun an Autorisatioun vun Apparater / Leit;
Datebank déi operationell an Archivdaten späichert:

Déi offiziell Versioun vu wat Hyperledger Fabric ass ka gelies ginn Site, a kuerz, Hyperledger Fabric ass eng Opensource Plattform déi Iech erlaabt privat Blockchainen ze bauen an arbiträr Smart Kontrakter auszeféieren, déi an de JS a Go Programméierungssprooche geschriwwe sinn. Loosst eis am Detail d'Architektur vum Hyperledger Fabric kucken a sécherstellen datt dëst en universelle System ass deen nëmmen Spezifizitéiten huet fir Daten ze späicheren an opzehuelen. D'Spezifizitéit ass datt d'Donnéeën, wéi an all Blockchainen, a Blocken gespäichert ginn, déi op der Blockchain plazéiert sinn nëmmen wann d'Participanten e Konsens erreechen an no der Opnam kënnen d'Donnéeën net roueg korrigéiert oder geläscht ginn.

Hyperledger Fabric Architektur

D'Diagramm weist d'Hyperledger Fabric Architektur:

Organisatiounen - Organisatiounen enthalen Peer, d.h. blockchain existéiert wéinst der Ënnerstëtzung vun Organisatiounen. Verschidde Organisatiounen kënnen Deel vun engem Kanal sinn.

Channel - eng logesch Struktur déi Peers a Gruppen verbënnt, d.h. de Blockchain ass spezifizéiert. Hyperledger Fabric kann gläichzäiteg verschidde Blockchaine mat verschiddene Geschäftslogik veraarbechten.

Membership Services Provider (MSP) ass e CA (Zertifizéierungsautoritéit) fir Identitéit auszeginn an Rollen ze ginn. Fir en Node ze kreéieren, musst Dir mam MSP interagéieren.

Peer Noden - Transaktiounen z'iwwerpréiwen, Blockchain späicheren, Smart Kontrakter ausféieren an interagéieren mat Uwendungen. Peer hunn eng Identitéit (digital Zertifika), déi vum MSP ausgestallt gëtt. Am Géigesaz zum Bitcoin oder Etherium Netzwierk, wou all Noden d'selwecht Rechter hunn, spillen Hyperledger Fabric Node verschidde Rollen:

Peer vläicht Ënnerstëtzung Peer (EP) a Smart Kontrakter ausféieren.
Engagéiert Peer (CP) - späichert nëmmen Daten am Blockchain an aktualiséieren den "Weltstaat".
Anker Peer (AP) - wann verschidden Organisatiounen un der Blockchain deelhuelen, da gi Verankerungskollegen fir d'Kommunikatioun tëscht hinnen benotzt. All Organisatioun muss een oder méi Ankerkollegen hunn. Mat AP kann all Peer an enger Organisatioun Informatioun iwwer all Peer an aner Organisatiounen kréien. Benotzt fir Informatioun tëscht APs ze synchroniséieren Klatsch Protokoll.
Leader Peer - wann eng Organisatioun e puer Peer huet, da kritt nëmmen de Leader vum Peer Blocks vum Bestellungsservice a gëtt se dem Rescht vun de Peer. De Leader kann entweder statesch spezifizéiert ginn oder dynamesch vun de Kollegen an der Organisatioun ausgewielt ginn. De Klatschprotokoll gëtt och benotzt fir Informatioun iwwer Leader ze synchroniséieren.

Verméigen - Entitéiten déi Wäert hunn a sinn op der Blockchain gespäichert. Méi spezifesch ass dëst Schlësselwäertdaten am JSON Format. Et sinn dës Donnéeën déi am Blockchain opgeholl ginn. Si hunn eng Geschicht, déi am Blockchain gespäichert ass, an en aktuellen Zoustand, deen an der "World State" Datebank gespäichert ass. Datestrukture ginn arbiträr gefëllt ofhängeg vu Geschäftsaufgaben. Et gi keng erfuerderlech Felder, déi eenzeg Empfehlung ass datt Verméigen e Besëtzer mussen hunn a wäertvoll sinn.

Ledger - besteet aus der Blockchain an der Word Staat Datebank, déi den aktuellen Zoustand vun Verméigen späichert. Weltstaat benotzt LevelDB oder CouchDB.

Smart Kontrakt - mat Smart Kontrakter gëtt d'Geschäftslogik vum System ëmgesat. Am Hyperledger Fabric ginn intelligent Kontrakter Kettecode genannt. Benotzt Kettecode, Verméigen an Transaktiounen iwwer si spezifizéiert. An technesch Begrëffer, Smart Kontrakter sinn Software Moduler implementéiert an der JS oder Go programméiere Sproochen.

Ënnerstëtzung Politik - fir all Kettecode kënnt Dir eng Politik festleeën wéivill Bestätegunge fir eng Transaktioun erwaart ginn a vu wiem. Wann d'Politik net festgeluecht ass, ass de Standard: "D'Transaktioun muss vun all Member vun all Organisatioun am Kanal bestätegt ginn." Beispiller vu Politiken:

D'Transaktioun muss vun all Administrateur vun der Organisatioun guttgeheescht ginn;
Muss vun all Member oder Client vun der Organisatioun bestätegt ginn;
Muss vun all Peer Organisatioun bestätegt ginn.

Bestellung Service - packt Transaktiounen a Blocken a schéckt se u Kollegen am Kanal. Garantéiert d'Liwwerung vu Messagen un all Kollegen am Netz. Benotzt fir industriell Systemer Kafka Message Broker, fir Entwécklung an Testen Solo.

CallFlow

D'Applikatioun kommunizéiert mat Hyperledger Fabric mat Go, Node.js oder Java SDK;
De Client erstellt eng tx Transaktioun a schéckt se un d'Ënnerstëtzung vu Kollegen;
De Peer verifizéiert d'Ënnerschrëft vum Client, mécht d'Transaktioun of a schéckt d'Endossement Ënnerschrëft un de Client zréck. Chaincode gëtt nëmmen op der Ënnerstëtzung Peer ausgefouert, an d'Resultat vu senger Ausféierung gëtt un all Peer geschéckt. Dësen Algorithmus vun der Aarbecht gëtt PBFT (Practical Byzantine Fault Tolerant) Konsens genannt. Ënnerscheed vun klassesch BFT d'Tatsaach datt de Message geschéckt gëtt an d'Bestätegung gëtt net vun all Participanten erwaart, awer nëmmen aus engem bestëmmte Set;
Nodeem de Client d'Zuel vun den Äntwerten entsprécht, entsprécht der Bestëmmungspolitik, schéckt hien d'Transaktioun un den Bestellungsservice;
Den Bestellungsservice generéiert e Block a schéckt et un all engagéierend Kollegen. Bestellungsservice garantéiert sequentiell Opnam vu Blocken, wat déi sougenannte Ledger Gabel eliminéiert (kuckt Rubrik "Gabel");
Peers kréien e Block, kontrolléiert d'Endossement Politik nach eng Kéier, schreift de Block an d'Blockchain an ännert den Zoustand an der "World State" DB.

Déi. Dëst resultéiert an enger Divisioun vu Rollen tëscht den Noden. Dëst garantéiert datt de Blockchain skalierbar a sécher ass:

Smart Kontrakter (chaincode) Leeschtunge Ënnerstëtzung Peer. Dëst garantéiert d'Confidentialitéit vun Smart Kontrakter, well et gëtt net vun alle Participanten gespäichert, awer nëmmen duerch d'Ënnerstëtzung vu Kollegen.
Bestellung soll séier funktionnéieren. Dëst ass garantéiert duerch d'Tatsaach datt d'Bestellung nëmmen e Block formt an et un e fixe Set vu Leadere schéckt.
Engagéiert Peer späicheren nëmmen de Blockchain - et kënne vill vun hinnen sinn a si erfuerderen net vill Kraaft an direkt Operatioun.

Méi Detailer iwwer d'architektonesch Léisunge vum Hyperledger Fabric a firwat et esou funktionnéiert an net anescht fannt Dir hei: Architektur Originen oder hei: Hyperledger Fabric: E verdeelt Betribssystem fir erlaabt Blockchains.

Also, Hyperledger Fabric ass e wierklech universelle System mat deem Dir kënnt:

Ëmsetzen arbiträr Geschäftslogik mam Smart Kontrakt Mechanismus;
Rekord a kritt Daten aus der Blockchain Datebank am JSON Format;
Gitt an z'iwwerpréiwen API Zougang mat Zertifika Autoritéit.

Elo wou mir e bëssen iwwer d'Spezifizitéite vum Hyperledger Fabric verstinn, loosst eis endlech eppes nëtzlech maachen!

Blockchain z'installéieren

Problemerklärung

D'Aufgab ass de Citcoin Netz mat de folgende Funktiounen ëmzesetzen: e Kont erstellen, e Gläichgewiicht kréien, Äre Kont eroplueden, Mënzen vun engem Kont op en aneren transferéieren. Loosst eis en Objektmodell zéien, dee mir weider an engem Smart Kontrakt ëmsetzen. Also, mir wäerte Konten hunn déi duerch Nimm identifizéiert ginn an e Gläichgewiicht enthalen, an eng Lëscht vu Konten. Konten an eng Lëscht vu Konten sinn, wat Hyperledger Fabric Verméigen ugeet. Deementspriechend hunn se eng Geschicht an en aktuellen Zoustand. Ech probéieren dat kloer ze zéien:

Déi Top Zuelen sinn den aktuellen Zoustand, deen an der Datebank "World State" gespäichert ass. Ënnert hinnen sinn Figuren déi d'Geschicht weisen déi am Blockchain gespäichert ass. Den aktuellen Zoustand vum Verméigen gëtt duerch Transaktiounen geännert. Den Asset ännert sech nëmmen als Ganzt, also als Resultat vun der Transaktioun gëtt en neien Objet erstallt, an den aktuelle Wäert vum Verméigen geet an d'Geschicht.

IBM Cloud

Mir schafen e Kont an IBM Cloud. Fir d'Blockchain Plattform ze benotzen, muss se op Pay-As-You-Go aktualiséiert ginn. Dëse Prozess ass vläicht net séier, well ... IBM freet zousätzlech Informatioun a verifizéiert se manuell. Op enger positiver Note kann ech soen datt IBM gutt Trainingsmaterialien huet, déi Iech erlaben Hyperledger Fabric an hirer Wollek z'installéieren. Ech hunn déi folgend Serie vun Artikelen a Beispiller gär:

Déi folgend sinn Screenshots vun der IBM Blockchain Plattform. Dëst ass net eng Instruktioun fir e Blockchain ze kreéieren, awer einfach eng Demonstratioun vum Ëmfang vun der Aufgab. Also, fir eis Zwecker, maache mir eng Organisatioun:

Mir kreéieren Noden dran: Orderer CA, Org1 CA, Orderer Peer:

Mir erstellen Benotzer:

Erstellt e Kanal a nennt et citcoin:

Wesentlech ass Channel e Blockchain, also fänkt et mat Block Null un (Genesis Block):

Schreiwen engem Smart Kontrakt

/*
 * Citcoin smart-contract v1.5 for Hyperledger Fabric
 * (c) Alexey Sushkov, 2019
 */
 
'use strict';
 
const { Contract } = require('fabric-contract-api');
const maxAccounts = 5;
 
class CitcoinEvents extends Contract {
 
    async instantiate(ctx) {
        console.info('instantiate');
        let emptyList = [];
        await ctx.stub.putState('accounts', Buffer.from(JSON.stringify(emptyList)));
    }
    // Get all accounts
    async GetAccounts(ctx) {
        // Get account list:
        let accounts = '{}'
        let accountsData = await ctx.stub.getState('accounts');
        if (accountsData) {
            accounts = JSON.parse(accountsData.toString());
        } else {
            throw new Error('accounts not found');
        }
        return accountsData.toString()
    }
     // add a account object to the blockchain state identifited by their name
    async AddAccount(ctx, name, balance) {
        // this is account data:
        let account = {
            name: name,
            balance: Number(balance),       
            type: 'account',
        };
        // create account:
        await ctx.stub.putState(name, Buffer.from(JSON.stringify(account)));
 
        // Add account to list:
        let accountsData = await ctx.stub.getState('accounts');
        if (accountsData) {
            let accounts = JSON.parse(accountsData.toString());
            if (accounts.length < maxAccounts)
            {
                accounts.push(name);
                await ctx.stub.putState('accounts', Buffer.from(JSON.stringify(accounts)));
            } else {
                throw new Error('Max accounts number reached');
            }
        } else {
            throw new Error('accounts not found');
        }
        // return  object
        return JSON.stringify(account);
    }
    // Sends money from Account to Account
    async SendFrom(ctx, fromAccount, toAccount, value) {
        // get Account from
        let fromData = await ctx.stub.getState(fromAccount);
        let from;
        if (fromData) {
            from = JSON.parse(fromData.toString());
            if (from.type !== 'account') {
                throw new Error('wrong from type');
            }   
        } else {
            throw new Error('Accout from not found');
        }
        // get Account to
        let toData = await ctx.stub.getState(toAccount);
        let to;
        if (toData) {
            to = JSON.parse(toData.toString());
            if (to.type !== 'account') {
                throw new Error('wrong to type');
            }  
        } else {
            throw new Error('Accout to not found');
        }
 
        // update the balances
        if ((from.balance - Number(value)) >= 0 ) {
            from.balance -= Number(value);
            to.balance += Number(value);
        } else {
            throw new Error('From Account: not enought balance');          
        }
 
        await ctx.stub.putState(from.name, Buffer.from(JSON.stringify(from)));
        await ctx.stub.putState(to.name, Buffer.from(JSON.stringify(to)));
                 
        // define and set Event
        let Event = {
            type: "SendFrom",
            from: from.name,
            to: to.name,
            balanceFrom: from.balance,
            balanceTo: to.balance,
            value: value
        };
        await ctx.stub.setEvent('SendFrom', Buffer.from(JSON.stringify(Event)));
 
        // return to object
        return JSON.stringify(from);
    }
 
    // get the state from key
    async GetState(ctx, key) {
        let data = await ctx.stub.getState(key);
        let jsonData = JSON.parse(data.toString());
        return JSON.stringify(jsonData);
    }
    // GetBalance   
    async GetBalance(ctx, accountName) {
        let data = await ctx.stub.getState(accountName);
        let jsonData = JSON.parse(data.toString());
        return JSON.stringify(jsonData);
    }
     
    // Refill own balance
    async RefillBalance(ctx, toAccount, value) {
        // get Account to
        let toData = await ctx.stub.getState(toAccount);
        let to;
        if (toData) {
            to = JSON.parse(toData.toString());
            if (to.type !== 'account') {
                throw new Error('wrong to type');
            }  
        } else {
            throw new Error('Accout to not found');
        }
 
        // update the balance
        to.balance += Number(value);
        await ctx.stub.putState(to.name, Buffer.from(JSON.stringify(to)));
                 
        // define and set Event
        let Event = {
            type: "RefillBalance",
            to: to.name,
            balanceTo: to.balance,
            value: value
        };
        await ctx.stub.setEvent('RefillBalance', Buffer.from(JSON.stringify(Event)));
 
        // return to object
        return JSON.stringify(from);
    }
}
module.exports = CitcoinEvents;

Intuitiv sollt alles hei kloer sinn:

Et gi verschidde Funktiounen (AddAccount, GetAccounts, SendFrom, GetBalance, RefillBalance) déi den Demo-Programm mat der Hyperledger Fabric API nennt.
D'SendFrom a RefillBalance Funktiounen generéieren Eventer déi den Demo Programm kritt.
D'Instantiatiounsfunktioun gëtt eemol genannt wann e Smart Kontrakt instantiéiert gëtt. Tatsächlech gëtt et net nëmmen eemol genannt, awer all Kéier wann d'Smart Kontrakt Versioun ännert. Dofir ass d'Initialiséierung vun enger Lëscht mat engem eidelen Array eng schlecht Iddi, well Elo, wa mir d'Versioun vum Smart Kontrakt änneren, wäerte mir déi aktuell Lëscht verléieren. Awer et ass an der Rei, ech léieren just).
Konten an eng Lëscht vu Konten sinn JSON Datestrukturen. JS gëtt fir Datemanipulatioun benotzt.
Dir kënnt den aktuelle Wäert vun engem Verméigen mam getState Funktiounsruff kréien, an aktualiséieren se mat putState.
Wann Dir e Kont erstellt, gëtt d'AddAccount Funktioun genannt, an där e Verglach fir déi maximal Zuel vu Konten am Blockchain gemaach gëtt (maxAccounts = 5). An hei gëtt et e Jamb (huet Dir gemierkt?), Wat zu enger endloser Erhéijung vun der Zuel vun de Konten féiert. Esou Feeler musse vermeit ginn)

Als nächst luede mir de Smart Kontrakt an de Kanal an instantiéieren et:

Loosst eis d'Transaktioun kucken fir Smart Contract z'installéieren:

Loosst eis d'Detailer iwwer eise Kanal kucken:

Als Resultat kréie mir de folgende Diagramm vun engem Blockchain Netzwierk an der IBM Cloud. D'Diagramm weist och en Demo-Programm deen an der Amazon Cloud op engem virtuelle Server leeft (méi doriwwer an der nächster Sektioun):

Erstellt eng GUI fir Hyperledger Fabric API Uriff

Hyperledger Fabric huet eng API déi benotzt ka ginn fir:

Kanal erstellen;
Verbindungen peer to Channel;
Installatioun an Instantiatioun vu Smart Kontrakter am Kanal;
Uruff Transaktiounen;
Ufro Informatiounen iwwer de Blockchain.

Applikatioun Entwécklung

An eisem Demo Programm wäerte mir d'API benotzen nëmmen Transaktiounen ze ruffen an Ufro Informatiounen, well Mir hunn déi verbleiwen Schrëtt scho mat der IBM Blockchain Plattform ofgeschloss. Mir schreiwen eng GUI mat engem Standard Technologie Stack: Express.js + Vue.js + Node.js. Dir kënnt e separaten Artikel schreiwen wéi Dir modern Webapplikatioune ufänkt ze kreéieren. Hei loossen ech e Link op déi Serie vu Virträg déi mir am meeschte gefall hunn: Voll Stack Web App benotzt Vue.js & Express.js. D'Resultat ass eng Client-Server Applikatioun mat engem vertraute grafeschen Interface am Google Material Design Stil. De REST API tëscht Client a Server besteet aus verschiddenen Uriff:

HyperledgerDemo/v1/init - d'Blockchain initialiséieren;
HyperledgerDemo/v1/accounts/list — kritt eng Lëscht vun alle Konten;
HyperledgerDemo/v1/account?name=Bob&balance=100 — erstellt Bob-Kont;
HyperledgerDemo/v1/info?account=Bob — kritt Informatiounen iwwer de Bob Kont;
HyperledgerDemo / v1 / Transaktioun? vun = Bob & zu = Alice & Volume = 2 - Transfert zwou Mënzen vum Bob op Alice;
HyperledgerDemo/v1/disconnect - d'Verbindung mat der Blockchain zoumaachen.

Beschreiwung vun der API mat Beispiller abegraff an Postman Websäit - e bekannte Programm fir HTTP API ze testen.

Demo Applikatioun an Amazon Cloud

Ech hunn d'Applikatioun op Amazon eropgelueden well ... IBM konnt nach ëmmer net mäi Kont upgraden an erlaabt mir virtuell Serveren ze kreéieren. Wéi eng Kiischt an d'Domain ze addéieren: www.citcoin.info. Ech halen de Server eng Zäitchen un, schalt en dann aus, well... Cents fir Loyer drëpsen, a Citcoin-Mënzen sinn nach net op der Bourse opgezielt) Ech schloen Screenshots vun der Demo am Artikel, fir datt d'Logik vun der Aarbecht kloer ass. D'Demo Applikatioun kann:

Initialiséiere vun der Blockchain;
Erstellt e Kont (awer elo kënnt Dir net en neie Kont erstellen, well déi maximal Unzuel u Konten, déi am Smart Kontrakt spezifizéiert sinn, am Blockchain erreecht gouf);
Kritt eng Lëscht vu Konten;
Transfert citcoin Mënzen tëscht Alice, Bob an Alex;
Kritt Eventer (awer elo gëtt et kee Wee fir Eventer ze weisen, also fir Simplicitéit seet d'Interface datt d'Evenementer net ënnerstëtzt ginn);
Log Aktiounen.

Als éischt initialiséieren mir de Blockchain:

Als nächst erstelle mir eise Kont, verschwend keng Zäit mam Gläichgewiicht:

Mir kréien eng Lëscht vun all verfügbare Konten:

Mir wielen de Sender an den Empfänger, a kréien hir Salden. Wann de Sender an den Empfänger d'selwecht sinn, da gëtt säi Kont ersat:

Am Log iwwerwaache mir d'Ausféierung vun Transaktiounen:

Eigentlech ass dat alles mam Demo Programm. Hei ënnen kënnt Dir eis Transaktioun am Blockchain gesinn:

An déi allgemeng Lëscht vun Transaktiounen:

Mat dësem hu mir d'Ëmsetzung vum PoC erfollegräich ofgeschloss fir de Citcoin Netzwierk ze kreéieren. Wat soss muss gemaach ginn fir Citcoin e vollwäertegt Netzwierk fir Mënzen ze transferéieren? Ganz kleng:

An der Schafung vun de Konten, implementéiert d'Generatioun vun engem privaten / ëffentleche Schlëssel. De private Schlëssel muss mam Kont Benotzer gespäichert ginn, den ëffentleche Schlëssel muss am Blockchain gespäichert ginn.
Maacht e Mënztransfer an deem en ëffentleche Schlëssel, anstatt en Numm, benotzt gëtt fir de Benotzer z'identifizéieren.
Verschlësselt Transaktioune vum Benotzer op de Server mat sengem private Schlëssel.

Konklusioun

Mir hunn de Citcoin Netz mat de folgende Funktiounen ëmgesat: e Kont addéieren, e Gläichgewiicht kréien, Äre Kont eroplueden, Mënzen vun engem Kont op en anere transferéieren. Also, wat huet et eis kascht e PoC ze bauen?

Dir musst Blockchain am Allgemengen studéieren an Hyperledger Fabric besonnesch;
Léiert IBM oder Amazon Wolleken ze benotzen;
Léiert d'JS Programméierungssprooch an e puer Web Kader;
Wann e puer Donnéeën musse gespäichert ginn net an der Blockchain, awer an enger separater Datebank, da léiert d'Integratioun, zum Beispill, mat PostgreSQL;
A lescht awer net zulescht - Dir kënnt net an der moderner Welt liewen ouni Wëssen iwwer Linux!)

Natierlech ass et keng Rakéitewëssenschaft, awer Dir musst haart schaffen!

Quellen op GitHub

Quellen opgesat GitHub. Kuerz Beschreiwung vum Repository:
Katalog «Server» — Node.js Server
Katalog «Client» — Node.js Client
Katalog «blockchain"(Parameterwäerter a Schlësselen, natierlech, funktionnéieren net a ginn nëmmen als Beispill uginn):

Kontrakt - Smart Kontrakt Quellcode
Portemonnaie - Benotzerschlëssel fir d'Hyperledger Fabric API ze benotzen.
*.cds - kompiléiert Versioune vu Smart Kontrakter
*.json Dateien - Beispiller vu Konfiguratiounsdateien fir d'Hyperledger Fabric API ze benotzen

Et ass nëmmen den Ufank!

Source: will.com

Blockchain: wat PoC solle mir bauen?