Blockchain met Hyperledger Fabric Blockchain met Hyperledger Fabric

Hyperledger Fabric is als de James Bond van blockchainplatforms - soepel, verfijnd en met een licentie om te schalen. Het is een open-source project gehost door de Linux Foundation, ontworpen voor het creëren van permissiegebaseerde blockchainnetwerken. Zie het als een blockchain met een uitsmijter bij de deur - niet iedereen komt binnen, maar degenen die dat wel doen, hebben een geweldige tijd.

Belangrijke kenmerken die Fabric onderscheiden:

Modulaire architectuur (mix en match componenten zoals een blockchainbuffet)
Inplugbare consensusmechanismen (want één maat past niet iedereen)
Privacy en vertrouwelijkheid (wat er in het kanaal gebeurt, blijft in het kanaal)
Smart contracts in algemene programmeertalen (geen noodzaak om Solidity te leren!)

De Bouwstenen: De Architectuur van Hyperledger Fabric

Laten we de belangrijkste componenten van de architectuur van Fabric opsplitsen. Het is als een hightech Lego-set, maar in plaats van een ruimteschip te bouwen, creëer je een veilig, schaalbaar blockchainnetwerk.

Peers: De Werkpaarden

Peers zijn de ruggengraat van het netwerk. Ze onderhouden het grootboek, draaien chaincode (de chique naam van Fabric voor smart contracts) en valideren transacties. Zie ze als de ijverige kantoormedewerkers die ervoor zorgen dat alles soepel verloopt.

Kanalen: De Waterkoelers

Kanalen zijn privé "sub-netwerken" waar specifieke netwerkleden privé kunnen handelen. Het is als aparte chatrooms voor verschillende afdelingen - Marketing hoeft niet te weten wat IT aan het doen is, toch?

Orderers: De Verkeersleiders

Orderers zijn verantwoordelijk voor de consistente volgorde van transacties en het creëren van blokken. Ze zijn als de luchtverkeersleiders van de blockchainwereld, die ervoor zorgen dat alles in de juiste volgorde landt.

Organisaties: De Afdelingen

Organisaties vertegenwoordigen de verschillende entiteiten die deelnemen aan het netwerk. Ze kunnen verschillende bedrijven, afdelingen of zelfs die ene persoon van de boekhouding zijn die erop staat zijn eigen afdeling te zijn.

Je Fabric Speelplaats Opzetten

Nu we de theorie hebben behandeld, laten we aan de slag gaan. Het opzetten van Hyperledger Fabric is als het in elkaar zetten van IKEA-meubels - het lijkt in eerste instantie ingewikkeld, maar met de juiste tools en een beetje geduld heb je voor je het weet een functioneel netwerk.

Stap 1: Maak Je Tools Klaar

Eerst moet je enkele vereisten installeren. Het is als inpakken voor een kampeertrip, maar in plaats van insectenspray en marshmallows heb je nodig:

Docker (want containers zijn het nieuwe zwart)
Docker Compose (voor het orkestreren van je containersymfonie)
Go (de taal van keuze voor Fabric)
Node.js en npm (voor wanneer je helemaal javascriptachtig wilt worden)
Python (want waarom niet nog een taal toevoegen aan de mix?)

Stap 2: Clone de Fabric Voorbeelden

Fabric biedt een set voorbeeldnetwerken om je op weg te helpen. Het is als een starterspakket in een videogame, maar dan voor blockchain:


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

Stap 3: Download Fabric Binaries en Docker Images

Voer het magische script uit dat alles downloadt wat je nodig hebt:


./scripts/bootstrap.sh

Dit script is als je persoonlijke blockchainbutler - het haalt alle benodigde componenten en Docker-images voor je op.

Stap 4: Start Je Eerste Netwerk

Laten we nu het "first-network" voorbeeld opstarten:


cd first-network
./byfn.sh generate
./byfn.sh up

Als alles goed gaat, zou je een heleboel containers tot leven moeten zien komen, als een miniatuur blockchainstad.

Je Innerlijke Blockchain Aanboren: Kanalen Creëren en Beheren

Kanalen in Hyperledger Fabric zijn als VIP-ruimtes in een club - exclusief, privé en waar alle belangrijke deals plaatsvinden. Laten we er een maken:


peer channel create -o orderer.example.com:7050 -c mychannel -f ./channel-artifacts/channel.tx --tls --cafile /opt/gopath/src/github.com/hyperledger/fabric/peer/crypto/ordererOrganizations/example.com/orderers/orderer.example.com/msp/tlscacerts/tlsca.example.com-cert.pem

Dit commando is als het fluisteren van een geheime wachtwoord aan de uitsmijter - het creëert een nieuw kanaal genaamd "mychannel".

Deelnemen aan het Feest

Nu we onze VIP-ruimte (kanaal) hebben gecreëerd, laten we enkele peers uitnodigen:


peer channel join -b mychannel.block

Dit commando is in feite het versturen van feestuitnodigingen naar je peers.

Smart Contracts: De Hersenen van de Operatie

In Hyperledger Fabric worden smart contracts chaincode genoemd. Het is als het noemen van een smartphone een "draagbaar rekenapparaat" - hetzelfde, maar met een chiquere naam.

Je Eerste Chaincode Schrijven

Laten we een eenvoudige chaincode in Go schrijven. Het is als het schrijven van een takenlijst, maar dan voor je blockchain:


package main

import (
    "fmt"
    "github.com/hyperledger/fabric-contract-api-go/contractapi"
)

type SmartContract struct {
    contractapi.Contract
}

func (s *SmartContract) Set(ctx contractapi.TransactionContextInterface, key string, value string) error {
    return ctx.GetStub().PutState(key, []byte(value))
}

func (s *SmartContract) Get(ctx contractapi.TransactionContextInterface, key string) (string, error) {
    value, err := ctx.GetStub().GetState(key)
    if err != nil {
        return "", fmt.Errorf("failed to read from world state: %v", err)
    }
    if value == nil {
        return "", fmt.Errorf("the asset %s does not exist", key)
    }
    return string(value), nil
}

func main() {
    chaincode, err := contractapi.NewChaincode(&SmartContract{})
    if err != nil {
        fmt.Printf("Error creating chaincode: %s", err.Error())
        return
    }
    if err := chaincode.Start(); err != nil {
        fmt.Printf("Error starting chaincode: %s", err.Error())
    }
}

Deze chaincode is als een sleutel-waarde opslag met blockchain superkrachten. Het kan waarden instellen en ophalen, wat spannender is dan het klinkt als je met onveranderlijke grootboeken werkt.

Je Chaincode Implementeren

Het implementeren van chaincode is als het uitbrengen van je app in de App Store, maar met meer consensus en minder wachten op goedkeuring:


peer lifecycle chaincode package mycc.tar.gz --path /path/to/your/chaincode --lang golang --label mycc_1
peer lifecycle chaincode install mycc.tar.gz

Deze commando's verpakken en installeren je chaincode. Het is als het inpakken van je code en het vervolgens onder de blockchainkerstboom plaatsen.

Zakendoen: Interactie met Je Blockchain

Nu we onze chaincode hebben geïmplementeerd, laten we het iets laten doen:


peer chaincode invoke -o orderer.example.com:7050 --tls --cafile /path/to/orderer/tls/cert.pem -C mychannel -n mycc -c '{"Args":["Set","hello","world"]}'

Dit commando roept onze chaincode aan, waarbij de waarde "world" wordt ingesteld voor de sleutel "hello". Het is als het verzenden van een zeer belangrijke, cryptografisch beveiligde "Hello, World!" boodschap.

Om de waarde terug te lezen:


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

Als alles goed gaat, zou je "world" moeten zien verschijnen. Gefeliciteerd, je hebt zojuist een volledige cyclus van blockchainoperaties voltooid!

API's en SDK's: De Brug tussen Blockchain en de Buitenwereld

Hyperledger Fabric biedt SDK's voor Node.js en Java, waarmee je applicaties kunt bouwen die communiceren met je blockchainnetwerk. Het is als het bouwen van een chique gebruikersinterface voor je blockchain backend.

Hier is een snel voorbeeld met de Node.js SDK:


const { Gateway, Wallets } = require('fabric-network');
const path = require('path');
const fs = require('fs');

async function main() {
    try {
        // laad de netwerkconfiguratie
        const ccpPath = path.resolve(__dirname, '..', '..', 'first-network', 'connection-org1.json');
        const ccp = JSON.parse(fs.readFileSync(ccpPath, 'utf8'));

        // Maak een nieuw bestandssysteemgebaseerd wallet voor het beheren van identiteiten.
        const walletPath = path.join(process.cwd(), 'wallet');
        const wallet = await Wallets.newFileSystemWallet(walletPath);

        // Controleer of we de gebruiker al hebben ingeschreven.
        const identity = await wallet.get('user1');
        if (!identity) {
            console.log('Een identiteit voor de gebruiker "user1" bestaat niet in de wallet');
            console.log('Voer de registerUser.js applicatie uit voordat je het opnieuw probeert');
            return;
        }

        // Maak een nieuwe gateway voor verbinding met onze peernode.
        const gateway = new Gateway();
        await gateway.connect(ccp, { wallet, identity: 'user1', discovery: { enabled: true, asLocalhost: true } });

        // Haal het netwerk (kanaal) op waar ons contract is geïmplementeerd.
        const network = await gateway.getNetwork('mychannel');

        // Haal het contract van het netwerk.
        const contract = network.getContract('mycc');

        // Dien de gespecificeerde transactie in.
        await contract.submitTransaction('Set', 'hello', 'world');
        console.log('Transactie is ingediend');

        // Ontkoppel van de gateway.
        await gateway.disconnect();

    } catch (error) {
        console.error(`Transactie indienen mislukt: ${error}`);
        process.exit(1);
    }
}

main();

Dit script is als een Zwitsers zakmes voor je blockchain - het maakt verbinding met het netwerk, dient een transactie in en ontkoppelt dan beleefd.

Je Blockchain Fort Beveiligen: Toegangscontrole en Beveiliging

Beveiliging in Hyperledger Fabric is als een ui - het heeft lagen. Laten we er een paar afpellen:

Membership Service Providers (MSP's)

MSP's zijn als de uitsmijters van je blockchainnetwerk. Ze beheren identiteiten en stellen de regels vast voor wie wat kan doen. Hier is een fragment uit een typische MSP-configuratie:


Organizations:
  - &OrdererOrg
      Name: OrdererOrg
      ID: OrdererMSP
      MSPDir: crypto-config/ordererOrganizations/example.com/msp
  - &Org1
      Name: Org1MSP
      ID: Org1MSP
      MSPDir: crypto-config/peerOrganizations/org1.example.com/msp
      AnchorPeers:
        - Host: peer0.org1.example.com
          Port: 7051

Deze configuratie is als een gastenlijst voor je blockchainfeest - het definieert wie is uitgenodigd en welke rollen ze spelen.

Toegangscontrolelijsten (ACL's)

ACL's in Fabric zijn als de "Alleen voor Personeel" borden in een winkel - ze bepalen wie toegang heeft tot welke bronnen. Hier is een voorbeeld van een ACL-beleid:


ACLs: &ACLsDefault
    lscc/GetDeploymentSpec: /Channel/Application/Readers
    lscc/GetChaincodeData: /Channel/Application/Readers
    lscc/GetInstantiatedChaincodes: /Channel/Application/Readers
    qscc/GetChainInfo: /Channel/Application/Readers
    qscc/GetBlockByNumber: /Channel/Application/Readers
    qscc/GetBlockByHash: /Channel/Application/Readers
    qscc/GetTransactionByID: /Channel/Application/Readers
    qscc/GetBlockByTxID: /Channel/Application/Readers
    cscc/GetConfigBlock: /Channel/Application/Readers
    peer/Propose: /Channel/Application/Writers
    peer/ChaincodeToChaincode: /Channel/Application/Readers
    event/Block: /Channel/Application/Readers
    event/FilteredBlock: /Channel/Application/Readers

Deze ACL-configuratie is als het instellen van verschillende beveiligingsniveaus in je blockchain spionagebureau.

Je Blockchain Monitoren: Omdat Blokken Kijken Leuk is

Het monitoren van een Hyperledger Fabric-netwerk is als een blockchain badmeester zijn - je moet alles in de gaten houden om ervoor te zorgen dat het soepel verloopt.

Prometheus en Grafana: Je Blockchain Dashboard

Prometheus is geweldig voor het verzamelen van statistieken, terwijl Grafana die statistieken omzet in mooie grafieken. Hier is een snelle setup:

Voeg Prometheus-configuratie toe aan je peer:


metrics:
    provider: prometheus

Stel een Prometheus-server in om deze statistieken te verzamelen
Verbind Grafana met Prometheus en maak dashboards

Nu kun je je transacties per seconde bekijken alsof het de nieuwste kaskraker is.

Conclusie: Je Bent Nu een Fabric-ated Blockchain Expert

Gefeliciteerd! Je hebt zojuist een wervelende tour door Hyperledger Fabric gemaakt. Van het opzetten van je eerste netwerk tot het monitoren van je blockchainbaby, je bent nu uitgerust om blockchainapplicaties van ondernemingsklasse te creëren.

Onthoud, Hyperledger Fabric is als een blockchain Zwitsers zakmes - het is veelzijdig, krachtig en in het begin een beetje ingewikkeld. Maar met oefening zul je het als een professional hanteren in een mum van tijd.

Dus ga op pad en blockchain verantwoord. En onthoud, in de wereld van Fabric is elk blok een bouwsteen voor iets groters. Veel codeerplezier, en moge je grootboek altijd gedistribueerd zijn!