Blockchain mit Hyperledger Fabric Blockchain mit Hyperledger Fabric

Hyperledger Fabric ist wie der James Bond der Blockchain-Plattformen - geschmeidig, raffiniert und mit einer Lizenz zum Skalieren. Es ist ein Open-Source-Projekt, das von der Linux Foundation gehostet wird und für die Erstellung von genehmigten Blockchain-Netzwerken entwickelt wurde. Stellen Sie sich das wie eine Blockchain mit einem Türsteher vor - nicht jeder kommt rein, aber diejenigen, die es tun, haben eine großartige Zeit.

Wichtige Merkmale, die Fabric hervorheben:

Modulare Architektur (komponieren Sie Komponenten wie ein Blockchain-Buffet)
Pluggable Konsensmechanismen (denn eine Größe passt nicht allen)
Privatsphäre und Vertraulichkeit (was im Kanal passiert, bleibt im Kanal)
Smart Contracts in allgemeinen Programmiersprachen (keine Notwendigkeit, Solidity zu lernen!)

Die Bausteine: Die Architektur von Hyperledger Fabric

Lassen Sie uns die wichtigsten Komponenten der Fabric-Architektur aufschlüsseln. Es ist wie ein High-Tech-Lego-Set, aber anstatt ein Raumschiff zu bauen, erstellen Sie ein sicheres, skalierbares Blockchain-Netzwerk.

Peers: Die Arbeitstiere

Peers sind das Rückgrat des Netzwerks. Sie pflegen das Ledger, führen Chaincode aus (Fabric's schicker Name für Smart Contracts) und validieren Transaktionen. Denken Sie an sie als die fleißigen Büroangestellten, die alles reibungslos am Laufen halten.

Kanäle: Die Wasserkühler

Kanäle sind private "Sub-Netzwerke", in denen bestimmte Netzwerkmitglieder privat Transaktionen durchführen können. Es ist wie separate Chatrooms für verschiedene Abteilungen zu haben - das Marketing muss nicht wissen, was die IT vorhat, oder?

Orderer: Die Verkehrsleiter

Orderer sind verantwortlich für die konsistente Reihenfolge der Transaktionen und das Erstellen von Blöcken. Sie sind wie die Fluglotsen der Blockchain-Welt und sorgen dafür, dass alles in der richtigen Reihenfolge landet.

Organisationen: Die Abteilungen

Organisationen repräsentieren die verschiedenen Entitäten, die am Netzwerk teilnehmen. Sie könnten verschiedene Unternehmen, Abteilungen oder sogar dieser eine Typ aus der Buchhaltung sein, der darauf besteht, seine eigene Abteilung zu sein.

Einrichten Ihres Fabric-Spielplatzes

Jetzt, da wir die Theorie verstanden haben, lassen Sie uns praktisch werden. Das Einrichten von Hyperledger Fabric ist wie das Zusammenbauen von IKEA-Möbeln - es sieht anfangs kompliziert aus, aber mit den richtigen Werkzeugen und etwas Geduld haben Sie schneller ein funktionierendes Netzwerk, als Sie denken.

Schritt 1: Bereiten Sie Ihre Werkzeuge vor

Zuerst müssen Sie einige Voraussetzungen installieren. Es ist wie das Packen für einen Campingausflug, aber anstelle von Insektenspray und Marshmallows benötigen Sie:

Docker (weil Container das neue Schwarz sind)
Docker Compose (um Ihre Container-Symphonie zu orchestrieren)
Go (die bevorzugte Sprache von Fabric)
Node.js und npm (für den Fall, dass Sie JavaScript verwenden möchten)
Python (weil warum nicht eine weitere Sprache hinzufügen?)

Schritt 2: Klonen Sie die Fabric-Beispiele

Fabric bietet eine Reihe von Beispielnetzwerken, um Ihnen den Einstieg zu erleichtern. Es ist wie ein Starterpaket in einem Videospiel, aber für Blockchain:


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

Schritt 3: Laden Sie Fabric-Binärdateien und Docker-Images herunter

Führen Sie das magische Skript aus, das alles herunterlädt, was Sie benötigen:


./scripts/bootstrap.sh

Dieses Skript ist wie Ihr persönlicher Blockchain-Butler - es holt alle notwendigen Komponenten und Docker-Images für Sie.

Schritt 4: Starten Sie Ihr erstes Netzwerk

Jetzt starten wir das "first-network"-Beispiel:


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

Wenn alles gut geht, sollten Sie eine Menge Container zum Leben erwecken sehen, wie eine Miniatur-Blockchain-Stadt.

Ihr inneres Blockchain-Potenzial nutzen: Erstellen und Verwalten von Kanälen

Kanäle in Hyperledger Fabric sind wie VIP-Räume in einem Club - exklusiv, privat und dort, wo alle wichtigen Geschäfte stattfinden. Lassen Sie uns einen erstellen:


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

Dieser Befehl ist wie das Flüstern eines geheimen Passworts an den Türsteher - er erstellt einen neuen Kanal namens "mychannel".

Der Party beitreten

Jetzt, da wir unseren VIP-Raum (Kanal) erstellt haben, laden wir einige Peers ein:


peer channel join -b mychannel.block

Dieser Befehl ist im Wesentlichen das Versenden von Partyeinladungen an Ihre Peers.

Smart Contracts: Das Gehirn der Operation

In Hyperledger Fabric werden Smart Contracts als Chaincode bezeichnet. Es ist wie ein Smartphone als "tragbares Rechengerät" zu bezeichnen - dasselbe, nur mit einem schickeren Namen.

Schreiben Ihres ersten Chaincodes

Lassen Sie uns einen einfachen Chaincode in Go schreiben. Es ist wie das Schreiben einer To-Do-Liste, aber für Ihre 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())
    }
}

Dieser Chaincode ist wie ein Schlüssel-Wert-Speicher mit Blockchain-Superkräften. Er kann Werte setzen und abrufen, was spannender ist, als es klingt, wenn man mit unveränderlichen Ledgers arbeitet.

Bereitstellen Ihres Chaincodes

Das Bereitstellen von Chaincode ist wie das Veröffentlichen Ihrer App im App Store, aber mit mehr Konsens und weniger Wartezeit auf die Genehmigung:


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

Diese Befehle verpacken und installieren Ihren Chaincode. Es ist wie das Einpacken Ihres Codes als Geschenk und dann das Platzieren unter dem Blockchain-Baum.

Geschäfte abwickeln: Interaktion mit Ihrer Blockchain

Jetzt, da wir unseren Chaincode bereitgestellt haben, lassen Sie uns ihn etwas tun lassen:


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"]}'

Dieser Befehl ruft unseren Chaincode auf und setzt den Wert "world" für den Schlüssel "hello". Es ist wie das Senden einer sehr wichtigen, kryptografisch sicheren "Hallo, Welt!"-Nachricht.

Um den Wert zurückzulesen:


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

Wenn alles gut geht, sollten Sie "world" angezeigt bekommen. Herzlichen Glückwunsch, Sie haben gerade einen vollständigen Zyklus von Blockchain-Operationen abgeschlossen!

APIs und SDKs: Die Brücke zwischen Blockchain und der Außenwelt

Hyperledger Fabric bietet SDKs für Node.js und Java, mit denen Sie Anwendungen erstellen können, die mit Ihrem Blockchain-Netzwerk interagieren. Es ist wie das Erstellen einer schicken Benutzeroberfläche für Ihr Blockchain-Backend.

Hier ist ein kurzes Beispiel mit dem Node.js SDK:


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

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

        // Create a new file system based wallet for managing identities.
        const walletPath = path.join(process.cwd(), 'wallet');
        const wallet = await Wallets.newFileSystemWallet(walletPath);

        // Check to see if we've already enrolled the user.
        const identity = await wallet.get('user1');
        if (!identity) {
            console.log('An identity for the user "user1" does not exist in the wallet');
            console.log('Run the registerUser.js application before retrying');
            return;
        }

        // Create a new gateway for connecting to our peer node.
        const gateway = new Gateway();
        await gateway.connect(ccp, { wallet, identity: 'user1', discovery: { enabled: true, asLocalhost: true } });

        // Get the network (channel) our contract is deployed to.
        const network = await gateway.getNetwork('mychannel');

        // Get the contract from the network.
        const contract = network.getContract('mycc');

        // Submit the specified transaction.
        await contract.submitTransaction('Set', 'hello', 'world');
        console.log('Transaction has been submitted');

        // Disconnect from the gateway.
        await gateway.disconnect();

    } catch (error) {
        console.error(`Failed to submit transaction: ${error}`);
        process.exit(1);
    }
}

main();

Dieses Skript ist wie ein Schweizer Taschenmesser für Ihre Blockchain - es verbindet sich mit dem Netzwerk, führt eine Transaktion aus und trennt dann höflich die Verbindung.

Sichern Ihrer Blockchain-Festung: Zugriffskontrolle und Sicherheit

Sicherheit in Hyperledger Fabric ist wie eine Zwiebel - sie hat Schichten. Lassen Sie uns ein paar davon aufdecken:

Membership Service Providers (MSPs)

MSPs sind wie die Türsteher Ihres Blockchain-Netzwerks. Sie verwalten Identitäten und legen die Regeln fest, wer was tun kann. Hier ist ein Ausschnitt aus einer typischen MSP-Konfiguration:


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

Diese Konfiguration ist wie eine Gästeliste für Ihre Blockchain-Party - sie definiert, wer eingeladen ist und welche Rollen sie spielen.

Access Control Lists (ACLs)

ACLs in Fabric sind wie die "Nur für Mitarbeiter"-Schilder in einem Geschäft - sie kontrollieren, wer auf welche Ressourcen zugreifen kann. Hier ist ein Beispiel für eine ACL-Richtlinie:


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

Diese ACL-Konfiguration ist wie das Einrichten verschiedener Sicherheitsfreigabestufen in Ihrer Blockchain-Spionageagentur.

Überwachung Ihrer Blockchain: Weil das Beobachten von Blöcken Spaß macht

Die Überwachung eines Hyperledger Fabric-Netzwerks ist wie ein Blockchain-Rettungsschwimmer zu sein - Sie müssen alles im Auge behalten, um sicherzustellen, dass es reibungslos läuft.

Prometheus und Grafana: Ihr Blockchain-Dashboard

Prometheus ist großartig zum Sammeln von Metriken, während Grafana diese Metriken in hübsche Grafiken verwandelt. Hier ist eine schnelle Einrichtung:

Fügen Sie die Prometheus-Konfiguration zu Ihrem Peer hinzu:


metrics:
    provider: prometheus

Richten Sie einen Prometheus-Server ein, um diese Metriken abzurufen
Verbinden Sie Grafana mit Prometheus und erstellen Sie Dashboards

Jetzt können Sie Ihre Transaktionen pro Sekunde beobachten, als wäre es der neueste Blockbuster-Film.

Fazit: Sie sind jetzt ein Fabric-Experte für Blockchain

Herzlichen Glückwunsch! Sie haben gerade eine rasante Tour durch Hyperledger Fabric gemacht. Vom Einrichten Ihres ersten Netzwerks bis zur Überwachung Ihres Blockchain-Babys sind Sie jetzt in der Lage, Blockchain-Anwendungen auf Unternehmensniveau zu erstellen.

Denken Sie daran, Hyperledger Fabric ist wie ein Schweizer Taschenmesser für Blockchain - vielseitig, leistungsstark und anfangs etwas kompliziert. Aber mit Übung werden Sie es bald wie ein Profi beherrschen.

Also gehen Sie hinaus und nutzen Sie Blockchain verantwortungsbewusst. Und denken Sie daran, in der Welt von Fabric ist jeder Block ein Baustein für etwas Größeres. Viel Spaß beim Programmieren, und möge Ihr Ledger immer verteilt sein!