Cryptomonnaie

Première tentative d'opération de code de chaîne dans Hyperledger Fabric version 2.0

Première tentative d'opération de code de chaîne dans Hyperledger Fabric version 2.0


1*1u71xjimW5CBNEAfO4cLWw - Première tentative d'opération de code de chaîne dans Hyperledger Fabric version 2.0

Hyperledger Fabric a récemment publié 2.0. Parmi les nombreux changements, un accrocheur concerne le fonctionnement du code de chaîne, c'est-à-dire le déploiement du code de chaîne sur un canal d'un réseau de matrice à utiliser. Bien que la documentation fournisse une explication très détaillée, cet article montre la différence par rapport à la version précédente en utilisant le premier réseau et le code de chaîne SACC comme démonstration. En le voyant côte à côte, nous pouvons mieux comprendre le processus et certains détails derrière la scène.

Nous commençons par une présentation rapide de l'ensemble du processus dans les versions 1.4 et 2.0. Ensuite, une démonstration sur chaque version montre étape par étape le processus de chaincode.

Notez qu'il s'agit de la toute première étude rapide du nouveau code 2.0. Au fil du temps, certaines parties de l'article seront mises à jour, après une exploration plus détaillée et testée. Néanmoins, j'espère que cet article donne une première compréhension de ce sujet et vous aide dans votre exploration.

L'opération de code de chaîne se réfère ici au déploiement d'un code de chaîne développé et testé sur un canal d'un réseau de matrice, de sorte que le monde extérieur puisse invoquer et interroger les fonctions de code de chaîne selon la logique de codage à l'intérieur. Une fois qu'un code de chaîne est développé et testé, il est d'abord conditionné et installé sur des pairs sélectionnés. Le code de chaîne n'est pas encore utilisable à ce stade jusqu'à ce que le code de chaîne soit validé (le terme utilisé dans la version 2.0) sur un canal (ou instancié sur un canal dans la version 1.4). Le code de chaîne est alors prêt pour que les utilisateurs autorisés invoquent ou interrogent la fonction de code de chaîne.

Voici une illustration rapide du flux dans les deux versions, côte à côte dans une perspective fonctionnelle.

Une illustration côte à côte approximative du fonctionnement du code de chaîne des deux versions.

Version 1.4

Dans la version 1.4 (documentation), le processus se compose des étapes suivantes: empaquetage, installation et instanciation. Une étape de conditionnement est nécessaire si le code de chaîne appartient à plusieurs parties. Si la propriété multiple n'est pas requise, l'installation du code de chaîne effectuera l'étape de conditionnement.

Dans installation de chaincode, nous spécifions les pairs cibles. Nous installons uniquement le code de chaîne sur les pairs qui seront utilisés pour appeler et interroger les fonctions de code de chaîne plus tard.

À ce stade, le code de chaîne installé ne peut pas être utilisé mais il n'est pas instancié sur le canal. Une fois le package chaincode installé dans ces homologues sélectionnés, nous pouvons effectuer instanciation de chaincode, une étape qui rend le code de chaîne utilisable dans le canal. Techniquement, l'instanciation du chaincode «invoque le chaincode du système de cycle de vie (lscc) pour créer et initialiser un chaincode sur un canal». L'instanciation du code de chaîne nécessite les informations du canal et la politique d'approbation lors de l'appel de ce code de chaîne. De plus, si chaincode contient le code initial dans Init (), l'argument est également fourni ici.

Une fois le code de chaine instancié, le code de chaine est prêt à l'emploi, et on peut invoquer (interroger) les fonctions de code de chaine en conséquence.

Avec ceci comme base, nous pouvons maintenant jeter un œil à la nouvelle version 2.0.

Version 2.0

De manière générale, la version 2.0 suit le même flux de processus, mais apporte certains changements dans les commandes et certains processus backend. Le flux global peut être divisé en quatre étapes: emballage, installation, approbation par les organisations et validation du code de chaîne. En gros, les deux premiers correspondent à l'installation de chaincode dans la version 1.4, tandis que les deux derniers à l'instanciation de chaincode. Mais l'instanciation terminologique n'est plus utilisée.

le emballage chaincode l'étape consiste à créer un fichier de package (fichier tar), avec le code de chaîne et certaines métadonnées du code de chaîne. Une étiquette est donnée au colis. Bien que le conditionnement puisse être effectué séparément par les organisations, il est plus courant de le faire par une seule organisation pour créer ce package et le distribuer à toutes les organisations pour garantir le même code de chaîne entre elles.

le installation l'étape consiste à installer ce fichier de package dans les homologues sélectionnés. Comme précédemment, seuls les homologues impliqués dans l'appel et la requête de code de chaîne nécessitent l'installation de code de chaîne. Et le code de chaîne n'est pas encore utilisable car il n'est pas encore engagé sur un canal. Le résultat de l'installation du code de chaîne est un identifiant de package (ID de package), au format .

le approbation par les organisations est l'étape ajoutée dans la version 2.0. Dans la version précédente, nous pouvions laisser une organisation «instancier» le code de chaîne à utiliser. Dans la version 2.0, les organisations doivent approuver explicitement le code de chaîne. L'exigence du nombre d'organisations nécessaires est régie par la politique d'approbation du cycle de vie, qui par défaut est définie comme la majorité. Dans une configuration à deux organisations, l'approbation est requise pour les deux organisations. Le service de commande est impliqué dans le processus d'approbation car un nouveau bloc est généré à chaque approbation. Cela signifie que tous les pairs connaissent le statut d'approbation.

Une fois l'approbation obtenue, nous devons spécifier sur quel canal le code de chaîne doit être déployé. Certaines informations sont requises, telles que l'approbation de la politique, un indicateur indiquant si le code Init () code à exécuter ou non, etc. C'est également la différence par rapport à la version 1.4 lors de la gestion du code de chaîne Init () fonction, et nous le verrons plus tard.

Une fois les approbations du nombre d'organisations requises obtenues, le code de chaîne est prêt à être validé. Nous passons maintenant à l'étape finale: la validation du code de chaîne.

le commit chaincode étape est initiée par toute organisation. Le processus nécessite d'abord l'approbation des organisations si elles ont approuvé le code de chaîne. Ensuite, une transaction est soumise au service de commande et un nouveau bloc est créé et tous les pairs l'ont engagé dans le grand livre.

Le cycle de vie du chaincode est maintenant terminé et le chaincode est prêt à être utilisé, c'est-à-dire que l'on peut appeler et interroger les fonctions de chaincode.

Une note sur Init (): Init () contient le code à exécuter avant toute autre fonction à invoquer et ne peut être exécuté qu'une seule fois au début. Dans la version 1.4, le Init () lorsque le code de chaîne est instancié. Dans la version 2.0, nous devons invoquer explicitement le Init () après validation du code de chaîne. Nous préciserons l'exigence de Init () lors de l'approbation et de la validation du code de chaîne. Et avec cela, nous ne pouvons pas invoquer d'autres fonctions jusqu'à ce que nous ayons invoqué le Init (). Il est indiqué dans la démonstration ci-dessous.

Par souci d'exhaustivité, voici quelques informations rapides sur Premier réseau et SACC Chaincode. Les deux sont livrés avec un référentiel d'échantillons de tissu.

Premier réseau est une configuration à deux organisations, chacune ayant deux pairs. Un canal mychannel est créé et rejoint par tous les pairs (quatre au total). First Network est bien scénarisé avec byfn.sh, qui est livré avec des options. Pour une meilleure compréhension de First Network, vous pouvez vous référer à mon article précédent. Dans notre démonstration, nous n'exécuterons pas le code de chaîne par défaut (chaincode_example02 dans la version 1.4, s'abstenir dans la version 2.0) mais utilisez SACC pour la démonstration.

SACC signifie code d'actif simple. Il simule un stockage clé / valeur dans le grand livre. Lors du premier déploiement, il nécessite une paire clé / valeur initiale. Deux fonctions sont définies. Ensemble() est invoqué lorsque l'on a besoin de modifier la valeur d'une clé existante ou d'ajouter une nouvelle paire clé / valeur, tandis que avoir() est invoquée (requêtes) lorsque l'on vérifie la valeur d'une clé donnée.

Avec cette introduction rapide, nous commençons la démonstration sur les deux versions.

Nous allons d'abord lancer First Network sans le code de chaîne (en utilisant l'option -n). Après cela, nous lancerons le code de chaine SACC en mettant l'accent sur le cycle de vie du code de chaîne.

Voici les étapes de la démonstration

  1. Affichez le premier réseau sans code de chaîne
  2. Installer le SACC sur des pairs sélectionnés
  3. Instancier SACC sur mychannel avec les arguments initiaux et le résultat de la requête
  4. Invoquer ensemble() pour une nouvelle valeur et un résultat de requête d'un autre pair

Étape 1: Affichez le premier réseau sans code de chaîne

Le premier réseau est opérationnel avec canal ma Chaîne créé et rejoint par tous les pairs. Notez que First Network dans la version 1.4.4 utilise Solo comme implémentation du service de commande et qu'un seul client est en cours d'exécution. En outre, nous voyons que les quatre homologues sont en cours d'exécution et une CLI est là pour notre opération de code de chaîne.

Nous pouvons maintenant commencer à travailler sur le déploiement de chaincode.

Étape 2: installer le SACC sur des pairs sélectionnés

Ici, nous sautons l'étape d'emballage et laissons l'installation effectuer l'emballage. Les cibles sont peer0.org1 et peer0.org2, car nous utilisons uniquement ces deux nœuds dans cette démo pour l'invocation et l'interrogation de code de chaîne.

Étape 3: instancier SACC sur ma Chaîne avec les arguments initiaux et le résultat de la requête

Notez qu'il existe un Init () code dans le SACC. Lorsque nous instancions le code de chaîne, nous devons fournir l'argument requis défini dans le Init () une fonction. Ici, nous spécifions la clé comme Nom et valeur kc comme arguments.

Si nous jetons maintenant un œil sur les journaux de n'importe quel homologue, nous voyons un nouveau bloc # 3. (Il s'agit du bloc # 3 car nous avons le bloc de genèse de canal comme # 0, et les deux transactions de mise à jour des pairs d'ancrage dans les blocs # 1 et # 2.)

Une fois le code de chaine instancié avec la clé / valeur initiale fournie, nous pouvons interroger la valeur de la clé Nom.

Étape 4: invoquer ensemble() pour une nouvelle valeur et un résultat de requête d'un autre pair

Par souci de démonstration, nous invoquerons ensemble() sur peer0.org1, et avoir() la valeur sur peer0.org2, pour montrer que les choses fonctionnent correctement.

Nous voyons donc que tout fonctionne bien.

De même, avec 2.0.0, nous lancerons d'abord First Network sans le code de chaîne (en utilisant l'option -n). Après cela, nous lancerons le code de chaine SACC en mettant l'accent sur le cycle de vie du code de chaîne.

Voici les étapes de la démonstration

  1. Affichez le premier réseau sans code de chaîne
  2. Package SACC chaincode
  3. Installer le package sur les pairs sélectionnés
  4. Approuver le code de chaîne pour les deux organisations
  5. Validez le code chaine sur mychannel
  6. Invoquer Init () fonction avec arguments requis
  7. Invoquer ensemble() pour une nouvelle valeur et un résultat de requête d'un autre pair

Étape 1: Affichez le premier réseau sans code de chaîne

Le premier réseau est opérationnel avec canal ma Chaîne créé et rejoint par tous les pairs. Notez que First Network dans la version 2.0.0 utilise Raft comme implémentation du service de commande et que cinq clients au total sont en cours d'exécution. Au cours de la démonstration, nous utilisons uniquement orderer.example.com, mais n'hésitez pas à utiliser d'autres commandes également. En outre, nous voyons que les quatre homologues sont en cours d'exécution et une CLI est là pour notre opération de code de chaîne.

Étape 2: empaqueter le code de chaîne SACC

Nous devons d'abord gérer la dépendance (si ce n'est pas fait auparavant)

Ensuite, nous pouvons empaqueter le code de chaîne.

Un nouveau dossier sacc.tar.gz est créé dans le conteneur CLI.

Étape 3: installer le package sur les homologues sélectionnés

Ici, nous installons le package pour peer0.org1 et peer0.org2, car nous utilisons uniquement ces deux nœuds dans cette démo pour l'invocation et l'interrogation de code de chaîne.

Nous recevrons l'identifiant du package, qui sera nécessaire lorsque nous approuverons le code de chaîne à l'étape suivante. Notre ID de package est ici sacc_1: bf57… 6399.

Nous pouvons toujours vérifier l'installation de chaincode sur chaque pair avec requête de code de chaîne de cycle de vie homologue installée. Ceci est utile si nous devons trouver des ID de package.

Étape 4: approuver le code de chaîne pour les deux organisations

Selon la stratégie par défaut, la majorité des organisations de canaux est nécessaire avant de pouvoir valider le code de chaîne sur le canal (voir dans Application / Policies / LifecycleEndorsement dans configtx.yaml). La configuration actuelle comprend deux organisations, ce qui signifie qu'une approbation est nécessaire de la part des deux organisations avant que le code de chaîne ne puisse être validé.

Pour approuver ce package pour Org1,

Si nous jetons maintenant un œil sur les journaux de n'importe quel homologue, nous voyons un nouveau bloc # 3. (Il s'agit du bloc # 3 car nous avons le bloc de genèse de canal comme # 0, et les deux transactions de mise à jour d'ancrage dans les blocs # 1 et # 2.)

De même, nous approuvons ce package pour Org2.

Et sans surprise, nous voyons un autre nouveau bloc # 4 créé.

Notez que nous avons spécifié l'option init-requis dans la commande d'approbation. Le code chainc SACC contient du code dans Init (), et nous exécuterons l'invoquer Init () après que chaincode est engagé pour canaliser. Gardez un suivi à ce sujet dans les prochaines étapes.

Nous pouvons à tout moment vérifier la disponibilité du commit chaincode avec la commande (sur n'importe quel pair car tous les pairs reçoivent la mise à jour de ces nouveaux blocs).

Comme les deux organisations ont approuvé le code de chaîne, le code de chaîne est maintenant prêt à être validé.

Étape 5: Valider le code chaine sur mychannel

La validation de Chaincode peut être effectuée par un pair.

Et un nouveau bloc # 5 est engagé dans le grand livre.

Notez que nous incluons également init-requis dans la commande chaincode commit.

Et encore une fois, nous pouvons utiliser la commande requête de code de chaîne du cycle de vie des pairs pour vérifier l'état du commit chaincode.

Une fois que le code de chaîne est validé pour le canal, le cycle de vie du code de chaîne est terminé et le code de chaîne est prêt à être utilisé. Nous sommes de retour à l'appel et à la requête de code de chaîne, qui est le même que les versions précédentes.

Étape 6: invoquer Init () fonction avec arguments requis

Par conception de code de chaîne SACC, il y a du code dans Init (). Par conséquent, avant d'appeler d'autres fonctions de code de chaîne, nous invoquerons d'abord le Init () avec les arguments requis. Ici, nous spécifions la clé comme Nom et valeur kc. Notez que dans la commande, nous avons l'option isInit montrant qu'il appelle la Init ().

Maintenant, nous pouvons interroger le résultat pour la clé Nom.

La valeur initiale est correctement enregistrée dans le grand livre.

Étape 7: invoquer ensemble() pour une nouvelle valeur et un résultat de requête d'un autre pair

Comme précédemment, dans un but de démonstration, nous invoquerons ensemble() sur peer0.org1, et avoir() la valeur sur peer0.org2, pour montrer que les choses fonctionnent correctement. Notez que nous ne signalons pas isInit plus.

Encore une fois, tout fonctionne bien.

Voici la première tentative de voir la différence de fonctionnement du code de chaîne dans la version 2.0 par rapport à la version précédente via une démonstration. Comme dit précédemment, il y a encore beaucoup de plongée profonde. J'espère que cela servira de point de départ lorsque nous naviguerons dans le code de la version 2.0.

Afficher plus

SupportIvy

SupportIvy.com : Un lieu pour partager le savoir et mieux comprendre le monde. Meilleure plate-forme de support gratuit pour vous, Documentation &Tutoriels par les experts.

Articles similaires

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Bouton retour en haut de la page
Fermer