Faire fonctionner un réseau privé sur la blockchain NEO

2017/11/13 发布

Posted on 2017/11/13

Faire fonctionner un réseau privé sur la blockchain NEO est une part intégrale du travail sur blockchain, en particulier pour écrire et tester des contrats intelligents et dApps. Un réseau privé est comme une blockchain NEO complète juste pour vous-même, isolée des réseaux publics. Vous pouvez le faire tourner rapidement, réclamer les 100 millions de NEO initiaux, et expérimenter avec tous les aspects qui la compose.

Ce poste est un guide pas-à-pas pour expliquer comment mettre en place une chaîne privée avec Docker et Python sur Mac, Linux et Windows. C’est aussi une introduction à neo-python et neo-privatenet-docker.

Note à l’intention des utilisateurs Windows :

  • neo-python ne supporte pas Windows actuellement car LevelDB ne fonctionne que sur OSX et Linux. Vous pouvez quand même faire tourner un réseau privé avec le conteneur Docker, mais pour créer des portefeuilles et extraire des NEO et GAS vous devrez suivre les docs officiels NEO – Chaine privéeen commençant par l’étape 5.
  • Docker ne fonctionne pas avec l’édition familiale Windows 10, vous devrez passer par la version Pro.

 NEO ainsi que les outils de base sont développés en C# sur Windows. La documentation officielle NEO sur les chaines privées donne un bon aperçu sur la façon d’installer un réseau privé avec Windows toolchain et 4 machines virtuelles Windows comme nœuds de consensus.

Grâce aux efforts de la communauté City of Zion (CoZ), faire tourner une chaine privée est possible sur n’importe quelle plateforme avec Docker et Python, avec des exigences système minimales. Les deux projets spécifiques que nous allons utiliser sont neo-python et neo-privatenet-docker :

  • neo-python — Permet de faire tourner un nœud NEO complet et interagir avec la blockchain en passant par Python 3.
  • neo-privatenet-docker — Permet de faire tourner une blockchain NEO complète avec 4 nœuds de consensus dans un seul et léger conteneur Docker.

J’aimerais aussi mentionner ici neo-js, pour implanter des nœuds NEO sous JavaScript, avec plusieurs fonctionnalités dans les tuyaux. neo-js n’est pas aussi mature que neo-python, mais support déjà tous les RPC calls, et vous pouvez faire tourner un nœud local complet en enregistrant les données blockchain dans une base de données MongoDB.

 

 Installer une chaine privée NEO pas à pas

Les étapes sont les suivantes : Installation Docker → neo-privatenet-docker → neo-python → connexion au réseau privé et création d’un portefeuille → réclamer les 100 000 000 NEO initiaux.

 

Installation de Docker

 

Faire tourner la chaine privée Docker container

  • Cloner neo-privatenet-docker, puis construire et lancer le conteneur Docker avec les quatre nœuds de consensus initiaux :

$ git clone https://github.com/Splyse/neo-privatenet-docker.git
$ cd neo-privatenet-docker
$ ./docker_build.sh
$ ./docker_run.sh

 

  • Arrivé ici, le conteneur Docker fait tourner les nœuds de consensus en arrière-plan. Vous pouvez le voir avec $ docker ps :

$ docker ps
CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS                                  NAMES
6f7ed0d4ae3a        neo-privnet         "/bin/bash /opt/pr..."   2 hours ago         Up 2 hours          0.0.0.0:20333-20336->20333-20336/tcp   neo-privnet

 

  • Si vous rencontrez une erreur type  Get https://registry-1.docker.io/v2/library/ubuntu/manifests/16.04: unauthorized: incorrect username or password, vous devez ouvrir le Docker hub $ docker login avec votre identifiant utilisateur (pas votre email).
  • Lorsque le conteneur Docker s’arrête ou redémarre, all state est supprimé (la totalité de « l’ancienne » blockchain sera perdue). Vous devriez enlever Chains/privnet de neo-python  et de chaque portefeuille de réseau privé que vous aurez créé.

 

Neo-python

Maintenant nous pouvons nous connecter au réseau privé avec neo-python, créer un portefeuille et réclamer les NEO initiaux :

$ python prompt.py -c protocol.privnet.json
NEO cli. Type 'help' to get startedneo> -          Le nombre de blocs devrait augmenter de façon continue (ex : « Progress 0/1 »)-          Créer un portefeuille :neo> create wallet privnet
password> ************
password> ************
Script hash b"'\xbaI\xf7H\x13\x1d \x7fC5\xf1\x1d\x04!a\xb5\xce-\xb4" <class 'bytes'>
Wallet {
    "percent_synced": 0,
    "path": "privnet",
    "addresses": [
        "AKPwAZWyBWMdUe8NtoSYMeTmwCxrP4e2KB"
    ],
    "public_keys": [
        {
            "Public Key": "02ddeee35542a7e390395b0cca3a493ee001fee35b7710846b5b73bf0d888c133b",
            "Address": "AKPwAZWyBWMdUe8NtoSYMeTmwCxrP4e2KB"
        }
    ],
    "synced_balances": [],
    "height": 0
}
pubkey b'02ddeee35542a7e390395b0cca3a493ee001fee35b7710846b5b73bf0d888c133b' -          Noter l’adresse, dans notre exemple AKPwAZWyBWMdUe8NtoSYMeTmwCxrP4e2KB-          Fermer prompt.py (entrer exit ou appuyer sur CTRL + D)-          Réclamer les 100 000 000 de NEO : $ python contrib/privnet-claimall.py -c protocol.privnet.json -a {your-address} -          Cela va créer une transaction signée par 3 des 4 nœuds de consensus, et attendre que la blockchain confirme la transaction.-          Soyez patient, cela peut prendre quelques minutes. Arrivé ici, vous devriez avoir 100 millions de NEO dans votre portefeuille et faire ce que vous voulez. Vérifier la balance avec neo-python :  neo> open wallet privnet
password> ************
Opened wallet at privnet
neo> wallet
Script hash b'i\xd5r\xef\\\xf2=\xb32\xb7\xffe\xa4\t@6\xdbM\x1b\xb7' <class 'bytes'>
Wallet {
    "percent_synced": 100,
    "path": "privnet",
    "addresses": [
        {
            "votes": [],
            "balances": {
                "c56f33fc6ecfcd0c225c4ab356fee59390af8560be0e930faebe74a6daff7c9b": "100000000.0"
            },
            "version": 0,
            "is_watch_only": false,
            "frozen": false,
            "script_hash": "ARRUJLMrTipDfvzUGHNJ3qAAcQRSdtUcEX"
        }
    ],
    "public_keys": [
        {
            "Public Key": "02c017615119d81f4b3ab7ddb016e22e3313cacb6ab5cf2ef38addd752ac1b3d9f",
            "Address": "ARRUJLMrTipDfvzUGHNJ3qAAcQRSdtUcEX"
        }
    ],
    "synced_balances": [
        "[NEO]: 100000000.0 "
    ],
    "height": 402
} Voila ! Vous avec votre chaine privée NEO qui fonctionne et un contrôle total sur les fonds initiaux. Amusez-vous bien !

 

Redémarrer et réinitialiser le réseau privé

Le conteneur Docker ne conserve aucun état. S’il s’arrête ou redémarre, tout est perdu et la totalité de la blockchain sera recréée depuis le début au prochain démarrage.

Il est important de supprimer les anciens fichiers depuis neo-python (Chains/privnet). Autrement vous allez rencontrer des problèmes en lançant l’ancienne base de données dans une nouvelle chaine.

neo-python$ rm -rf Chains/privnet/

 

Vous pouvez redémarrer manuelle le réseau privé en lançant ./docker_run.sh. Cela va arrêter le conteneur neo-privnet s’il est lancé, et en démarrer un nouveau :

$ ./docker_run.sh
Stopping container named neo-privnet
Removing container named neo-privnet
Starting container...
7e23e2fe1475489503f4d6b6a619275d806043dbeb0672e981ec3938c875167f

 

Réclamer les GAS initiaux

Neo-python ne supporte pas encore la réclamation des GAS. Vous pouvez les réclamer avec les outils officiels NEO comme décrits dans les docs NEO chaine privée, en commençant par l’étape 5.

 

Astuces Docker

Voici quelques commandes utilisées régulièrement sur Docker :

  • docker ps liste toutes les instances en cours d’exécution, docker ps -a les arrête toutes. docs
  • docker images liste toutes les images locales depuis lesquels un conteneur peut être lancé. docs
  • docker exec -it {container-id} /bin/bash ouvre une interface bash dans le conteneur en cours d’exécution. docs
  • docker stop {container-id} arrête le conteneur. docs
  • docker rm -f {container-id} arrête et supprime le conteneur. docs
  • docker run commence un nouveau conteneur. docs

 

NEO TestNet

NEO fournit également un TestNet mais celui-ci ne devrait être utilisé que dans les phases finales de développement (pour diverses raisons).

 

Neo-python

neo-python est un projet incroyable, un travail de la communauté de réimplanter le projet NEO initial dans Python ! Il a déjà parcouru un long chemin et supporte les fonctionnalités suivantes :

  • Lancer sur un base Python un nœud NEO P2P
  • CLI interactive pour configurer un nœud ainsi qu’inspecter et interagir avec la blockchain.
  • Exécuter des contrats intelligents sur la blockchain dans une machine virtuelle Python.
  • Fonctionnalités Wallet basiques (pas encore complètement testées, merci de ne pas l’utiliser sur MainNet).

neo-python a fourché depuis un SDK Python « très » préliminaire, mais le développement n’a réellement commencé qu’à partir de Juillet 2017 avec des contributions constantes depuis :

A date du 3 Novembre 2017, neo-python a 18 contributeurs et est mené par localhuman.

Si vous souhaitez travailler avec la blockchain NEO sur une plateforme autre que Windows, vous pouvez être presque certain d’interagir avec neo-python d’une façon ou d’une autre. C’est une partie intégrante de la chaine de développement multi-plateforme, activement développée, tout simplement un excellent projet.

 

neo-privatenet-docker

Portons notre attention sur neo-privatenet-docker, qui nous permet de faire tourner facilement une blockchain NEO privée dans une image Docker Ubuntu. Une chaine privée requière au moins 4 nœuds de consensus qui sont toutes lancées dans ce seul conteneur Docker. Les principaux contributeurs sont hal0x2328 et phetter.

Commençons avec le Dockerfile :

 FROM ubuntu:16.04
MAINTAINER hal0x2328ENV DEBIAN_FRONTEND noninteractiveRUN apt-get update && apt-get upgrade -y
RUN apt-get install -y apt-utils
RUN apt-get install -y mininet netcat curl wget unzip less python screen
RUN apt-get install -y ca-certificates apt-transport-https
RUN apt-get install -y libleveldb-dev sqlite3 libsqlite3-dev
RUN apt-get install -y expectRUN curl https://packages.microsoft.com/keys/microsoft.asc | gpg --dearmor > /etc/apt/trusted.gpg.d/microsoft.gpg
RUN echo "deb [arch=amd64] https://packages.microsoft.com/repos/microsoft-ubuntu-xenial-prod xenial main" > /etc/apt/sources.list.d/dotnetdev.listRUN apt-get update && apt-get install -y dotnet-sdk-2.0.0RUN wget -O /opt/neo-cli.zip https://github.com/neo-project/neo-cli/releases/download/v2.3.2/neo-cli-ubuntu.16.04-x64.zip

 

  • Cette image est basée sur Ubuntu 16:04
  • Divers utilitaires systèmes sont installés, comprenant LevelDB un stockage de valeur-clé rapide de Google, et sqlite3 un moteur de base de données SQL transactionnel, autonome, sans serveur et zéro configuration.
  • Les référentiels Microsoft apt sont configurés et le dotnet-sdk-2.0.0 est installé. A noter, le projet NEO originel est en C# et tourne sous .NET Core.
  • La version Ubuntu de neo-cli est téléchargée.

C’est à peu près toute l’installation. Après ceci, neo-cli est extrait 4 fois (correspondant à chaque nœud de consensus), et les fichiers de démarrage de la chaine privée sont copiés :

RUN unzip -d /opt/node1 /opt/neo-cli.zip
RUN unzip -d /opt/node2 /opt/neo-cli.zip
RUN unzip -d /opt/node3 /opt/neo-cli.zip
RUN unzip -d /opt/node4 /opt/neo-cli.zipADD ./scripts/private_chain_start.sh /opt/
ADD ./scripts/start_cli.sh /opt/

 

Lorsque vous exécutez le conteneur Docker avec docker_run.sh, il démarre le conteneur avec 4 ports ouverts (20333-20336, mappés sur l’hôte) et appelle le script private_chain_start.sh :

docker run -d --name neo-privnet -p 20333-20336:20333-20336/tcp -h neo-privnet neo-privnet /bin/bash /opt/private_chain_start.sh /opt/

 

private_chain_start.sh à son tour démarre 4 nœuds NEO en exécutant start_cli.sh quatre fois :

#!/usr/bin/expect -f
set dnpath [lindex $argv 0]
set wallet [lindex $argv 1]
set password [lindex $argv 2]
set timeout -1
cd $dnpath
spawn dotnet neo-cli.dll
expect "neo>"
send "open wallet $wallet\n"
expect "password:"
send "$password\n"
expect "neo>"
send "start consensus\n"
expect "OnStart"
#expect "LIVEFOREVER"
interact

 

Ce code définit quelques variables à partir des arguments (dnpath, wallet, password), exécute dotnet neo-cli.dll, ouvre le portefeuille du nœud initial et appel start consensus afin que les nœuds commencent à fonctionner. A ce stade, des blocs dans la chaine privée sont en cours de création.

 C’est tout ! Même si cela ne ressemble pas à beaucoup de code, c'est une façon simple et accessible de commencer le développement sur blockchain NEO exécuter une chaîne privée. Encore un grand merci aux développeurs de ce projet !

 Je vous suggère d’essayer ça tout de suite ! Il suffit de suivre le guide de démarrage ci-dessus et vous pourrez exécuter votre propre chaine NEO privée en un rien de temps.

N’hésitez pas à vous joindre au Slack NEO et dire bonjour. Nous avons une communauté ouverte et accueillante ! Vous pouvez également trouver des liens vers d’autres ressources sur la page officielle NEO neo.org.