🥇Blockchain: Beth mae'n ei gostio i ni adeiladu PoC?

Mae fy llygaid yn ofnus, ond mae fy nwylo'n cosi!

Mewn erthyglau blaenorol, fe wnaethon ni edrych ar y technolegau y mae blockchains yn cael eu hadeiladu arnynt (Beth ddylem ni adeiladu blockchain?) ac achosion y gellir eu gweithredu gyda'u cymorth (Beth mae'n ei gostio i ni adeiladu achos?). Mae'n amser rhoi cynnig arni! Ar gyfer peilotiaid a PoCs (Prawf o Gysyniad), mae'n well gen i ddefnyddio'r cwmwl, gan ei fod yn hygyrch o unrhyw le yn y byd ac yn aml yn dileu'r angen am sefydlu amgylchedd diflas, gan fod ffurfweddiadau wedi'u ffurfweddu ymlaen llaw ar gael. Felly, gadewch i ni adeiladu rhywbeth syml, fel rhwydwaith ar gyfer trosglwyddo darnau arian rhwng cyfranogwyr, a gadewch i ni ei alw'n Citcoin. Byddwn yn defnyddio'r cwmwl IBM a'r blockchain Hyperledger Fabric cyffredinol. Yn gyntaf, gadewch i ni ddeall pam mae Hyperledger Fabric yn cael ei alw'n blockchain cyffredinol.

Ffabrig Hyperledger — blockchain cyffredinol

Yn gyffredinol, system wybodaeth gyffredinol yw:

Set o weinyddion a chraidd meddalwedd sy'n gweithredu rhesymeg fusnes;
Rhyngwynebau ar gyfer rhyngweithio â'r system;
Dulliau ar gyfer cofrestru, dilysu ac awdurdodi dyfeisiau/pobl;
Cronfa ddata sy'n storio data gweithredol ac archifol:

Gellir darllen y fersiwn swyddogol o beth yw Hyperledger Fabric yn Ar-leinYn gryno, mae Hyperledger Fabric yn blatfform ffynhonnell agored sy'n galluogi adeiladu cadwyni bloc preifat a gweithredu contractau clyfar wedi'u hysgrifennu yn JavaScript a Go. Gadewch i ni edrych yn agosach ar bensaernïaeth Hyperledger Fabric a gweld ei fod yn system gyffredinol, gyda gofynion penodol yn unig ar gyfer storio a chofnodi data. Y gofynion hyn yw, fel gyda phob cadwyn bloc, bod data'n cael ei storio mewn blociau, sydd ond yn cael eu hychwanegu at y gadwyn bloc os yw cyfranogwyr yn cyrraedd consensws, ac unwaith y byddant wedi'u hysgrifennu, ni ellir anwybyddu na dileu'r data.

Pensaernïaeth Ffabrig Hyperledger

Mae'r diagram yn dangos pensaernïaeth y Ffabric Hyperledger:

Sefydliadau — mae sefydliadau'n cynnwys cyfoedion, sy'n golygu bod y blockchain yn bodoli diolch i gefnogaeth sefydliadau. Gall gwahanol sefydliadau fod yn rhan o un sianel.

Sianel — strwythur rhesymegol sy'n uno cyfoedion yn grwpiau, gan ddiffinio blockchain felly. Gall Hyperledger Fabric brosesu blockchains lluosog ar yr un pryd â rhesymeg fusnes wahanol.

Darparwr Gwasanaethau Aelodaeth (MSP) — yn CA (Awdurdod Tystysgrif) ar gyfer cyhoeddi hunaniaethau a neilltuo rolau. I greu nod, mae angen i chi ryngweithio â'r MSP.

Nodau cyfoedion — gwirio trafodion, storio'r blockchain, gweithredu contractau clyfar, a rhyngweithio â chymwysiadau. Mae gan gyfoedion hunaniaeth (tystysgrif ddigidol) a gyhoeddir gan yr MSP. Yn wahanol i rwydweithiau Bitcoin neu Ethereum, lle mae pob nod yn gyfartal, yn Hyperledger Fabric mae nodau'n chwarae rolau gwahanol:

Gall cyfoedion fod cyfoedion sy'n cymeradwyo (EP) a gweithredu contractau clyfar.
Cyfoed sy'n ymrwymo (CP) - dim ond storio data yn y blockchain a diweddaru'r "Cyflwr Byd".
Cyfoed Angor (AP) - Os yw sawl sefydliad yn cymryd rhan mewn blockchain, defnyddir cyfoedion angor i gyfathrebu rhyngddynt. Rhaid i bob sefydliad gael un neu fwy o gyfoedion angor. Gan ddefnyddio AP, gall unrhyw gyfoed yn y sefydliad gael gwybodaeth am bob cyfoed mewn sefydliadau eraill. I gydamseru gwybodaeth rhwng APs, defnyddir rhwydwaith cyfoedion-i-gyfoedion. Protocol clecs.
Cyfoed Arweinydd Os oes gan sefydliad nifer o gyfoedion, dim ond y cyfoed arweinydd fydd yn derbyn blociau gan y Gwasanaeth Archebu ac yn eu dosbarthu i'r cyfoedion eraill. Gellir naill ai aseinio'r arweinydd yn statig neu ei ethol yn ddeinamig gan gyfoedion o fewn y sefydliad. Defnyddir y protocol clecs hefyd i gydamseru gwybodaeth am arweinwyr.

Asedau — endidau o werth sydd wedi'u storio yn y blockchain. Yn fwy penodol, data allwedd-gwerth ar fformat JSON yw'r rhain. Mae'r data hwn wedi'i gofnodi yn y "Blockchain." Mae ganddyn nhw hanes, sydd wedi'i storio yn y blockchain, a chyflwr cyfredol, sydd wedi'i storio yn y gronfa ddata "World State". Mae strwythurau data yn cael eu llenwi'n fympwyol yn dibynnu ar anghenion busnes. Nid oes unrhyw feysydd gofynnol; yr unig argymhelliad yw bod rhaid i asedau gael perchennog a chynrychioli gwerth.

Ledger — yn cynnwys blockchain a chronfa ddata World State, sy'n storio cyflwr cyfredol asedau. Mae World State yn defnyddio LevelDB neu CouchDB.

Contract smart — Mae contractau clyfar yn gweithredu rhesymeg fusnes y system. Yn Hyperledger Fabric, gelwir contractau clyfar yn chaincode. Defnyddir chaincode i ddiffinio asedau a thrafodion sy'n cynnwys nhw. Yn dechnegol, modiwlau meddalwedd sy'n cael eu gweithredu yn JS neu Go yw contractau clyfar.

Polisi cymeradwyo — Ar gyfer pob cod cadwyn, gallwch osod polisïau ar gyfer faint a chan bwy i ddisgwyl cadarnhad ar gyfer trafodiad. Os nad oes polisi wedi'i osod, y rhagosodiad yw "Rhaid i drafodiad gael ei gadarnhau gan unrhyw aelod o unrhyw sefydliad yn y sianel." Polisïau enghreifftiol:

Rhaid i'r trafodiad gael ei gadarnhau gan unrhyw weinyddwr yn y sefydliad;
Rhaid cael cadarnhad gan unrhyw aelod neu gleient o'r sefydliad;
Rhaid ei wirio gan unrhyw sefydliad cyfoedion.

Gwasanaeth archebu — yn pacio trafodion yn flociau ac yn eu hanfon at gyfoedion yn y sianel. Yn gwarantu danfon negeseuon i bob cyfoed yn y rhwydwaith. Ar gyfer systemau diwydiannol, fe'i defnyddir. Brocer negeseuon Kafka, ar gyfer datblygu a phrofi Unawd.

CallFlow

Mae'r rhaglen yn rhyngweithio â Hyperledger Fabric gan ddefnyddio Go, Node.js, neu Java SDK;
Mae'r cleient yn creu trafodiad tx ac yn ei anfon at gyfoedion sy'n cymeradwyo;
Mae'r cyfoed yn gwirio llofnod y cleient, yn gweithredu'r trafodiad, ac yn anfon y llofnod cymeradwyo yn ôl i'r cleient. Dim ond ar y cyfoed cymeradwyo y gweithredir Chaincode, a darlledir y canlyniad i bob cyfoed. Gelwir yr algorithm hwn yn gonsensws PBFT (Practical Byzantine Fault Tolerant). Mae'n wahanol i BFT clasurol y ffaith bod y neges yn cael ei hanfon a bod disgwyl cadarnhad nid gan bob cyfranogwr, ond gan set benodol yn unig;
Ar ôl i'r cleient dderbyn nifer yr ymatebion sy'n cyfateb i'r polisi cymeradwyo, mae'n anfon trafodiad i'r gwasanaeth Archebu;
Mae'r gwasanaeth archebu yn ffurfio bloc ac yn ei anfon at bob cyfoed sy'n ymrwymo. Mae'r gwasanaeth archebu yn sicrhau bod blociau'n cael eu hysgrifennu'n olynol, sy'n dileu'r hyn a elwir yn fforch ledger (gweler yr adran "Fforciau");
Mae cyfoedion yn derbyn y bloc, yn gwirio'r polisi cymeradwyo eto, yn ysgrifennu'r bloc i'r blockchain, ac yn newid y cyflwr yn y DB "Cyflwr y Byd".

Mae hyn yn arwain at rannu rolau rhwng nodau. Mae hyn yn sicrhau graddadwyedd a diogelwch y blockchain:

Mae contractau clyfar (cod cadwyn) yn cael eu gweithredu gan gyfoedion sy'n cymeradwyo. Mae hyn yn sicrhau cyfrinachedd contractau clyfar, gan mai dim ond cyfoedion sy'n cymeradwyo sy'n storio'r cod, nid gan bob cyfranogwr.
Rhaid i archebu fod yn gyflym. Mae hyn yn cael ei sicrhau gan y ffaith mai dim ond bloc y mae Archebu yn ei gynhyrchu ac yn ei anfon at set sefydlog o gyfoedion arweinwyr.
Dim ond y blockchain sy'n cael ei storio gan gyfoedion sy'n ymrwymo—gall fod llawer ohonyn nhw ac nid oes angen llawer o bŵer na gweithrediad ar unwaith arnyn nhw.

Gallwch ddysgu mwy am benderfyniadau pensaernïol Hyperledger Fabric a pham mae'n gweithio fel y mae yma: Tarddiad Pensaernïaeth neu yma: Ffabrig Hyperledger: System Weithredu Dosbarthedig ar gyfer Blockchains â Chaniatâd.

Felly, mae Hyperledger Fabric yn system wirioneddol gyffredinol sy'n eich galluogi i:

Gweithredu rhesymeg fusnes wedi'i haddasu gan ddefnyddio'r mecanwaith contract clyfar;
Ysgrifennu ac adfer data o gronfa ddata'r blockchain ar ffurf JSON;
Rhoi a gwirio mynediad API gan ddefnyddio'r Awdurdod Tystysgrif.

Nawr ein bod ni wedi trafod ychydig o fanylion Hyperledger Fabric, gadewch i ni wneud rhywbeth defnyddiol o'r diwedd!

Defnyddio'r blockchain

Datganiad o'r broblem

Y nod yw gweithredu rhwydwaith Citcoin gyda'r swyddogaethau canlynol: creu cyfrif, cael balans, ail-lenwi cyfrif, a throsglwyddo darnau arian o un cyfrif i'r llall. Gadewch i ni lunio model gwrthrych, y byddwn wedyn yn ei weithredu mewn contract clyfar. Felly, bydd gennym gyfrifon, wedi'u hadnabod gan enwau ac yn cynnwys balans, a rhestr o gyfrifon. Mae cyfrifon a'r rhestr o gyfrifon yn asedau yn nhermau Hyperledger Fabric. Yn unol â hynny, mae ganddynt hanes a chyflwr cyfredol. Byddaf yn ceisio darlunio hyn yn weledol:

Mae'r ffigurau uchaf yn cynrychioli'r cyflwr cyfredol sydd wedi'i storio yn y gronfa ddata "Cyflwr y Byd". Isod mae ffigurau sy'n dangos yr hanes sydd wedi'i storio yn y blockchain. Mae cyflwr cyfredol asedau yn cael ei newid gan drafodion. Dim ond yn ei gyfanrwydd y mae ased yn newid, felly mae gweithredu trafodiad yn creu gwrthrych newydd, ac mae gwerth cyfredol yr ased yn cael ei golli i'r hanes.

IBM Cloud

Creu cyfrif yn cwmwl IBMI ddefnyddio'r platfform blockchain, mae angen i chi ei uwchraddio i Dalu Wrth Fynd. Gall y broses hon gymryd llawer o amser, gan fod IBM yn gofyn am wybodaeth ychwanegol ac yn ei gwirio â llaw. Ar yr ochr gadarnhaol, gallaf ddweud bod gan IBM ddeunyddiau hyfforddi da ar gyfer defnyddio Hyperledger Fabric yn eu cwmwl. Hoffais y gyfres ganlynol o erthyglau ac enghreifftiau:

Isod mae sgrinluniau o blatfform Blockchain IBM. Nid canllaw i greu blockchain yw hwn, ond yn hytrach arddangosiad o gwmpas y dasg. At ein dibenion ni, byddwn yn creu un Sefydliad:

Ynddo rydym yn creu nodau: Archebwr CA, Org1 CA, Cyfoedion Archebu:

Rydym yn creu defnyddwyr:

Gadewch i ni greu Sianel a'i henwi'n citcoin:

Blockchain yw’r sianel yn ei hanfod, felly mae’n dechrau ar floc sero (bloc Genesis):

Ysgrifennu Contract Clyfar

/*
 * 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;

Yn reddfol, dylai popeth yma fod yn glir:

Mae sawl swyddogaeth (AddAccount, GetAccounts, SendFrom, GetBalance, RefillBalance) y bydd y rhaglen demo yn eu galw gan ddefnyddio'r API Hyperledger Fabric.
Mae'r ffwythiannau SendFrom ac RefillBalance yn cynhyrchu digwyddiadau y bydd y rhaglen demo yn eu derbyn.
Mae'r ffwythiant instantiate yn cael ei alw unwaith pan fydd y contract clyfar yn cael ei instantiate. Mewn gwirionedd, nid yw'n cael ei alw unwaith yn unig, ond bob tro y bydd fersiwn y contract clyfar yn newid. Felly, mae cychwyn y rhestr gydag arae gwag yn syniad gwael, gan y byddwn yn colli'r rhestr gyfredol pryd bynnag y bydd fersiwn y contract clyfar yn newid. Ond mae hynny'n iawn, dw i newydd ddysgu.
Strwythurau data JSON yw'r cyfrifon a'r rhestr o gyfrifon. Defnyddir JavaScript ar gyfer trin data.
Gallwch gael gwerth cyfredol ased drwy alw'r ffwythiant getState, a'i ddiweddaru gan ddefnyddio putState.
Pan fydd Cyfrif yn cael ei greu, mae'r ffwythiant AddAccount yn cael ei alw, sy'n cymharu'r nifer uchaf o gyfrifon yn y blockchain (maxAccounts = 5). Mae nam yma (wedi'i sylwi?) sy'n arwain at dwf anfeidrol yn nifer y cyfrifon. Dylid osgoi gwallau o'r fath.

Nesaf, rydym yn uwchlwytho'r contract clyfar i'r Sianel ac yn ei greu:

Beth am edrych ar y trafodiad ar gyfer gosod y Contract Clyfar:

Edrychwch ar fwy o fanylion am ein Sianel:

Dyma'r diagram rhwydwaith blockchain sy'n deillio o hyn yng nghwmwl IBM. Mae'r diagram hefyd yn cynnwys rhaglen demo sy'n rhedeg ar weinydd rhithwir yng nghwmwl Amazon (mwy am hyn yn yr adran nesaf):

Creu GUI ar gyfer Galwadau API Hyperledger Fabric

Mae gan Hyperledger Fabric API y gellir ei ddefnyddio i:

Creu sianeli;
Cysylltiadau cyfoedion i sianeli;
Gosod a chreu contractau clyfar mewn sianel;
Galw trafodion;
Gofyn am wybodaeth yn y blockchain.

Datblygu cais

Yn ein rhaglen demo, dim ond i gychwyn trafodion a gofyn am wybodaeth y byddwn yn defnyddio'r API, gan ein bod eisoes wedi cwblhau gweddill y camau gan ddefnyddio platfform blockchain IBM. Byddwn yn ysgrifennu'r GUI gan ddefnyddio pentwr technoleg safonol: Express.js + Vue.js + Node.js. Gellid ysgrifennu erthygl ar wahân am sut i ddechrau creu cymwysiadau gwe modern. Dyma ddolen i'r gyfres ddarlithoedd a fwynheais fwyaf: Ap Gwe Pentwr Llawn gan ddefnyddio Vue.js ac Express.jsY canlyniad yw cymhwysiad cleient-gweinydd gyda rhyngwyneb graffigol cyfarwydd yn null Dylunio Deunyddiau Google. Mae'r API REST rhwng y cleient a'r gweinydd yn cynnwys sawl galwad:

HyperledgerDemo/v1/init — cychwyn y blockchain;
HyperledgerDemo/v1/accounts/list — cael rhestr o'r holl gyfrifon;
HyperledgerDemo/v1/account?name=Bob&balance=100 — creu cyfrif Bob;
HyperledgerDemo/v1/info?account=Bob — cael gwybodaeth am y cyfrif Bob;
HyperledgerDemo/v1/transaction?from=Bob&to=Alice&volume=2 — trosglwyddo dau ddarn arian o Bob i Alice;
HyperledgerDemo/v1/datgysylltu — cau'r cysylltiad â'r blockchain.

Mae disgrifiad o'r API gydag enghreifftiau wedi'i bostio ar Gwefan y Postman — rhaglen adnabyddus ar gyfer profi APIs HTTP.

Cais demo yn y cwmwl Amazon

Llwythais yr ap i fyny i Amazon oherwydd nad yw IBM wedi gallu uwchraddio fy nghyfrif a chaniatáu i mi greu gweinyddion rhithwir eto. Ychwanegais barth fel y ceirios ar y brig: www.citcoin.infoByddaf yn cadw'r gweinydd i redeg am ychydig, yna'n ei ddiffodd, gan fod rhent yn dod i mewn, ac nid yw Citcoin wedi'i restru ar y gyfnewidfa eto. Rwy'n cynnwys sgrinluniau demo yn yr erthygl fel bod y rhesymeg yn glir. Gall yr ap demo:

Cychwyn y blockchain;
Creu Cyfrif (ond nawr nid yw'n bosibl creu Cyfrif newydd, gan fod y blockchain wedi cyrraedd y nifer uchaf o gyfrifon a bennir yn y contract clyfar);
Cael rhestr o Gyfrifon;
Trosglwyddo darnau arian citcoin rhwng Alice, Bob ac Alex;
Derbyn digwyddiadau (ond ar hyn o bryd nid oes ffordd o arddangos digwyddiadau, felly er mwyn symlrwydd mae'r rhyngwyneb yn nodi nad yw digwyddiadau'n cael eu cefnogi);
Cofnodi gweithredoedd.

Yn gyntaf, gadewch i ni gychwyn y blockchain:

Nesaf, crëwch eich cyfrif a pheidiwch â gwastraffu eich amser gyda'r balans:

Rydym yn cael rhestr o'r holl gyfrifon sydd ar gael:

Dewiswch yr anfonwr a'r derbynnydd a chewch eu balansau. Os yw'r anfonwr a'r derbynnydd yr un peth, bydd eu cyfrif yn cael ei ail-lenwi:

Rydym yn monitro gweithrediad trafodion yn y log:

Dyna'r cyfan am y rhaglen demo. Nesaf, gallwch weld ein trafodiad ar y blockchain:

A'r rhestr gyffredinol o drafodion:

Rydym wedi cwblhau PoC rhwydwaith Citcoin yn llwyddiannus. Beth arall sydd angen ei wneud i wneud Citcoin yn rhwydwaith llawn ar gyfer trosglwyddo darnau arian? Ychydig bach:

Yn ystod y cam creu cyfrif, gweithredwch gynhyrchu allweddi preifat/cyhoeddus. Dylai'r allwedd breifat gael ei storio gan ddefnyddiwr y cyfrif, a dylid storio'r allwedd gyhoeddus ar y gadwyn gadwyn.
Gwneud trosglwyddiad darn arian sy'n defnyddio allwedd gyhoeddus, yn hytrach nag enw, i adnabod y defnyddiwr.
Amgryptio trafodion sy'n mynd o'r defnyddiwr i'r gweinydd gyda'i allwedd breifat.

Casgliad

Fe wnaethon ni weithredu rhwydwaith Citcoin gyda'r nodweddion canlynol: ychwanegu cyfrif, cael eich balans, ail-lenwi eich cyfrif, a throsglwyddo darnau arian o un cyfrif i'r llall. Felly, faint oedd y gost i ni adeiladu'r PoC?

Mae angen astudio blockchain yn gyffredinol a Hyperledger Fabric yn benodol;
Dysgwch sut i ddefnyddio cwmwl IBM neu Amazon;
Dysgu'r iaith raglennu JS a rhywfaint o fframwaith gwe;
Os oes angen storio rhywfaint o ddata nid yn y blockchain, ond mewn cronfa ddata ar wahân, yna dysgwch sut i integreiddio â, er enghraifft, PostgreSQL;
Ac yn olaf ond nid lleiaf, heb wybodaeth Linux yn unman yn y byd modern!)

Nid gwyddoniaeth roced yw hi, ond bydd yn rhaid i chi weithio'n galed!

Ffynonellau ar GitHub

Rydw i wedi rhoi'r ffynonellau ymlaen GitHubDisgrifiad byr o'r storfa:
Catalog «gweinydd" — gweinydd Node.js
Catalog «cleient" — Cleient Node.js
Catalog «blockchain» (nid yw gwerthoedd a bysellau'r paramedr, wrth gwrs, yn gweithio ac fe'u rhoddir at ddibenion enghreifftiol yn unig):

contract — cod ffynhonnell contract clyfar
waled — allweddi defnyddiwr ar gyfer defnyddio'r API Hyperledger Fabric.
*.cds — fersiynau wedi'u crynhoi o gontractau clyfar
Ffeiliau *.json - ffeiliau ffurfweddu enghreifftiol ar gyfer defnyddio'r API Hyperledger Fabric

Dim ond y dechrau ydyw!

Ffynhonnell: hab.com