openblockchain
1.0.0
Le projet est divisé en plusieurs services :
Chaque service contient 1 ou plusieurs conteneurs et peut être mis à l'échelle indépendamment les uns des autres.
Toutes les images Docker sont hébergées : https://hub.docker.com/u/openblockchaininfo/
Les instructions suivantes vous guideront tout au long de l'installation de l'intégralité de l'application openblockchain, y compris toutes les dépendances et exigences du système vous permettant d'exécuter openblockchain à partir de la plupart des systèmes de base (Linux, OSX, Windows).
Les instructions commenceront par vous guider tout au long de l'installation d'Ubuntu sur VirtualBox.
En raison des exigences en matière de puissance de calcul et d'espace disque, le stockage et le traitement des données du projet ont été conçus pour être exécutés sur plusieurs machines, de préférence dans un cloud avec une gestion locale depuis une machine hôte.
Les instructions suivantes vous guident dans la configuration de votre machine hôte avec Ubuntu et docker-engine, docker-machine et docker-compose.
Vous devez d’abord installer VirtualBox en suivant ces instructions
Vous devez ensuite télécharger Ubuntu 16.04.1 LTS - 64 bits en suivant ces instructions
Vous devez créer une nouvelle machine virtuelle à l'aide de VirtualBox. La machine virtuelle (ci-après dénommée « la machine hôte ») sera utilisée pour déployer l'application. La machine hôte nécessite :
Lorsque vous démarrez la machine hôte pour la première fois, sélectionnez Ubuntu 16.04.1 LTS - 64 bits (que vous avez téléchargé à l'étape précédente) comme disque de démarrage (il est possible d'exécuter le projet sur d'autres versions d'Ubuntu et même d'autres systèmes d'exploitation tels que Windows et OS X, mais les instructions pour ceux-ci n'ont pas été incluses ici).
La machine hôte ne sera utilisée que pour envoyer des commandes au cluster.
Les machines du cluster (sur lesquelles les services seront déployés) nécessitent (chacune) :
Une fois la machine hôte configurée (voir la section « Prérequis » suivante), les instructions « Configuration du cluster » vous guideront à travers les étapes nécessaires à la création de 3 machines sur Scaleway.
Ceux-ci doivent être installés uniquement sur la machine hôte. Assurez-vous que Ubuntu est installé sur votre machine hôte (ce que vous aurez si vous avez suivi les étapes précédentes).
1. Installer le moteur Docker
Docker Engine inclut le client Docker. docker sera utilisé pour communiquer avec les démons docker qui s'exécutent sur chaque machine du cluster.
Mettez à jour les informations sur le package. Assurez-vous qu'APT fonctionne avec la méthode https et que les certificats CA sont installés :
$ sudo apt-get update
$ sudo apt-get install apt-transport-https ca-certificates
Ajoutez la clé GPG officielle et le référentiel APT :
$ sudo apt-key adv --keyserver hkp://p80.pool.sks-keyservers.net:80 --recv-keys 58118E89F3A912897C070ADBF76221572C52609D
$ sudo echo "deb https://apt.dockerproject.org/repo ubuntu-wily main" > /etc/apt/sources.list.d/docker.list
Mettez à jour l'index du package APT et installez Docker :
$ sudo apt-get update
$ sudo apt-get install docker-engine
Démarrez le démon Docker et vérifiez qu'il est correctement installé :
$ sudo service docker start
$ sudo docker run hello-world
Des instructions toujours à jour sont disponibles sur docker.com.
2. Installer la machine Docker
docker-machine est utilisé pour provisionner les machines pour le cluster.
Téléchargez le binaire Docker Machine 0.8 et extrayez-le dans votre PATH :
$ sudo curl -L https://github.com/docker/machine/releases/download/v0.8.0/docker-machine-`uname -s`-`uname -m` > /usr/local/bin/docker-machine
$ sudo chmod +x /usr/local/bin/docker-machine
Vérifiez l'installation en affichant la version de la machine :
$ docker-machine version
Des instructions toujours à jour sont disponibles sur docker.com.
3. Installez Docker Composer
Docker Compose est utilisé pour gérer les services.
$ sudo curl -L https://github.com/docker/compose/releases/download/1.8.0/docker-compose-`uname -s`-`uname -m` > /usr/local/bin/docker-compose
$ sudo chmod +x /usr/local/bin/docker-compose
Vérifiez l'installation en affichant la version de Compose :
$ docker-compose --version
Des instructions toujours à jour sont disponibles sur docker.com.
Vous avez maintenant configuré votre machine hôte. Tu as:
Cela vous permettra de gérer tous les microservices qui constituent l’application openblockchain depuis l’intérieur de la machine hôte.
Les instructions suivantes vous guident tout au long du déploiement du cluster dans le cloud, à l'aide de Scaleway. Le cluster contiendra les services suivants :
Les microservices sont gérés via docker-* sur votre machine hôte.
1. Créez le service de découverte
Utiliser Scaleway
Pour utiliser Scaleway, vous devez d'abord installer le pilote Scaleway pour Docker Machine :
$ wget https://github.com/scaleway/docker-machine-driver-scaleway/releases/download/v1.2.1/docker-machine-driver-scaleway_1.2.1_linux_amd64.tar.gz
$ tar -xvf docker-machine-driver-scaleway_1.2.1_linux_amd64.tar.gz
$ sudo cp docker-machine-driver-scaleway_1.2.1_linux_amd64/docker-machine-driver-scaleway /usr/local/bin/
$ sudo chmod +x /usr/local/bin/docker-machine-driver-scaleway
Créez une machine pour héberger un service de découverte Consul :
$ docker-machine create -d scaleway
--scaleway-commercial-type=C2S --scaleway-name=obc-consul
--scaleway-organization=<SCALEWAY-ACCESS-KEY> --scaleway-token=<SCALEWAY-SECRET-KEY>
obc-consul
Pointez votre client Docker vers la nouvelle machine :
$ eval $(docker-machine env obc-consul)
Créez et démarrez le service :
$ docker run --name consul --restart=always -p 8400:8400 -p 8500:8500
-p 53:53/udp -d progrium/consul -server -bootstrap-expect 1 -ui-dir /ui
2. Lancez le Docker Swarm (cluster)
Utiliser Scaleway
Vous pouvez provisionner les machines auprès de Scaleway, qui propose des serveurs haut de gamme abordables, parfaits pour ce projet.
Récupérez vos identifiants Scaleway (clé d'accès et clé secrète) depuis cette page, puis déployez 3 machines :
$ docker-machine create -d scaleway
--scaleway-commercial-type=C2L --scaleway-name=obc
--scaleway-organization=<SCALEWAY-ACCESS-KEY> --scaleway-token=<SCALEWAY-SECRET-KEY>
--swarm --swarm-master
--swarm-discovery consul://`docker-machine ip obc-consul`:8500
--engine-opt cluster-store=consul://`docker-machine ip obc-consul`:8500
--engine-opt cluster-advertise=eth0:2376
obc
$ docker-machine create -d scaleway
--scaleway-commercial-type=C2L --scaleway-name=obc-01
--scaleway-organization=<SCALEWAY-ACCESS-KEY> --scaleway-token=<SCALEWAY-SECRET-KEY>
--swarm
--swarm-discovery consul://`docker-machine ip obc-consul`:8500
--engine-opt cluster-store=consul://`docker-machine ip obc-consul`:8500
--engine-opt cluster-advertise=eth0:2376
obc-01
$ docker-machine create -d scaleway
--scaleway-commercial-type=C2L --scaleway-name=obc-02
--scaleway-organization=<SCALEWAY-ACCESS-KEY> --scaleway-token=<SCALEWAY-SECRET-KEY>
--swarm
--swarm-discovery consul://`docker-machine ip obc-consul`:8500
--engine-opt cluster-store=consul://`docker-machine ip obc-consul`:8500
--engine-opt cluster-advertise=eth0:2376
obc-02
Par défaut les machines Scaleway disposent d'un disque de 50 Go. Cependant, Scaleway attache également un SSD de 250 Go, qui doit être monté manuellement :
$ printf "obcnobc-01nobc-02" |
xargs -n 1 -I CONT_NAME docker-machine ssh CONT_NAME
"echo ; echo ; echo CONT_NAME ;"`
`"echo 'Formatting...' ;"`
`"yes | mkfs -t ext4 /dev/sda ;"`
`"echo 'Mounting...' ;"`
`"mkdir -p /openblockchain ;"`
`"mount /dev/sda /openblockchain ;"`
`"echo 'Adding to fstab...' ;"`
`"echo '/dev/sda /openblockchain auto defaults,nobootwait,errors=remount-ro 0 2' >> /etc/fstab ;"`
`"echo 'Done' ;"
Ce stockage supplémentaire ne sera pas visible au sein de l'UI de votre compte Scaleway. Vous pouvez vérifier manuellement que le stockage supplémentaire a été monté (dans ce cas, en vérifiant obc) :
$ docker-machine ssh obc
$ cat /etc/fstab
$ ls -al /openblockchain
3. Vérifiez l'essaim
Pointez votre environnement Docker vers la machine exécutant le swarm master :
$ eval $(docker-machine env --swarm obc)
Imprimer les informations sur le cluster :
$ docker info
Vous pouvez également lister les IP que Consul a "découvertes" :
$ docker run --rm swarm list consul://`docker-machine ip obc-consul`:8500
1. Créez le réseau par défaut
Créez un réseau superposé qui permet aux conteneurs de « se voir », quel que soit le nœud sur lequel ils se trouvent :
$ docker network create --driver overlay --subnet 10.0.9.0/24 obcnet
Liste tous les réseaux, obcnet doit être affiché en overlay :
$ docker network ls
openblockchain a été conçu avec plusieurs microservices qui sont liés dans le moteur Docker principal en tant que sous-modules git.
La commande suivante clone le projet et tous les gitmodules requis.
$ git clone --recursive https://github.com/open-blockchain/openblockchain.git
Une fois que vous avez cloné le dépôt, assurez-vous d'aller dans le répertoire.
$ cd openblockchain
2. Debout !
Depuis le dossier racine (qui contient docker-compose.yml ), exécutez :
$ docker-compose up -d --build
Docker déploiera tous les services. Par défaut, il lancera :
3. Vérifiez les services
Afficher tous les conteneurs et leur statut (ils doivent tous être "Up") :
$ docker-compose ps
Affichez l'état du cluster Cassandra (vous devriez voir 3 nœuds) :
$ docker-compose exec cassandra-seed nodetool status
Entre-temps, le serveur Bitcoin aurait déjà dû scanner quelques centaines de blocs. Voyons le fonctionnement en direct :
$ docker-compose logs -f --tail 100 bitcoin
Vous devriez voir quelque chose comme ceci, ce qui signifie qu'il a téléchargé tous les blocs de 0 à 187591 (dans cet exemple) :
bitcoin_1 | 2016-08-25 15:03:16 UpdateTip: new best=00000000000006edbd5920f77c4aeced0b8d84e25bb5123547bc6125bffcc830 height=187589 log2_work=68.352088 tx=4696226 date=2012-07-05 03:45:13 progress=0.015804 cache=48.7MiB(122719tx)
bitcoin_1 | 2016-08-25 15:03:16 UpdateTip: new best=00000000000003f07c1227f986f4687d291af311a346f66247c504b332510931 height=187590 log2_work=68.352117 tx=4696509 date=2012-07-05 03:52:33 progress=0.015805 cache=48.7MiB(122815tx)
bitcoin_1 | 2016-08-25 15:03:16 UpdateTip: new best=00000000000002b34a755d25a5fee4c0ad0c018cf94f4b0afef6aabe823d304a height=187591 log2_work=68.352146 tx=4696593 date=2012-07-05 04:01:11 progress=0.015805 cache=48.7MiB(122839tx)
Voyons maintenant les tableaux de bord Spark, qui devraient être vides pour le moment. Exécutez la commande suivante pour obtenir l'URL du tableau de bord de chaque maître et travailleur Spark :
$ echo "master: "`docker-machine ip obc`":8080"
$ echo "worker 1: "`docker-machine ip obc-01`":8081"
$ echo "worker 2: "`docker-machine ip obc-02`":8081"
1. Scannez la blockchain
Afficher les journaux des scanners :
$ docker-compose logs -f --tail 100 scanner-01
$ docker-compose logs -f --tail 100 scanner-02
Les scanners ont été configurés (dans docker-compose.yml ) pour qu'ils indexent une plage fixe de blocs. Cependant, au début, lorsque le nœud Bitcoin n'a pas encore atteint le bloc 330 000, scanner-02 (qui est configuré pour analyser les blocs de 330 000 à 400 000) ne pourra rien analyser. Par conséquent, il attendra 10 minutes, puis réessayera jusqu'à ce que ces blocs soient disponibles.
2. Analyse des étincelles
Le service spark-submit exécute plusieurs scripts Spark toutes les heures. Ces scripts génèrent des visualisations (c'est-à-dire des points de données) que l'API fournira au frontend. Vous pouvez voir sa progression en consultant les journaux :
$ docker-compose logs -f --tail 100 spark-submit
Exécutons un script personnalisé qui compte tous les blocs et transactions dans Cassandra :
$ docker-compose exec spark-submit sbt submit-Counter
Une fois le script terminé, vous devriez voir quelque chose comme ceci (ignorez les journaux qui commencent par un horodatage) :
Blocks: 239699
Transactions: 18941698
3. Accédez à l'API
Recherchez le nom de la machine sur laquelle le conteneur API s'exécute :
$ docker ps --filter "name=node-api" --format "{{.Names}}"
Cela produira quelque chose comme obc-02/api , où la partie avant la barre oblique est le nom de la machine.
Obtenez maintenant l'URL de l'API, en remplaçant <machine-name-from-above> en conséquence :
$ echo "http://"`docker-machine ip <machine-name-from-above>`":10010"
4. Accédez à l'interface de l'application Web
Recherchez le nom de la machine sur laquelle le conteneur frontal s'exécute :
$ docker ps --filter "name=frontend" --format "{{.Names}}"
Cela affichera quelque chose comme obc-01/frontend , où la partie avant la barre oblique est le nom de la machine.
Obtenez maintenant l'URL du frontend, en remplaçant <machine-name-from-above> en conséquence :
$ echo "http://"`docker-machine ip <machine-name-from-above>`":80"
5. Visualisations
Selon que le service spark-submit a eu le temps de terminer les scripts Spark ou non, vous pouvez voir des visualisations dans le frontend, à l' http://<frontend-ip>:80/blocks .
Si les visualisations ne sont pas encore disponibles, vérifiez la progression de spark-submit :
$ docker-compose logs -f --tail 100 spark-submit
S'il est inactif, redémarrez le service ( docker-compose restart spark-submit ). Sinon, il s'agit probablement du traitement des données de Cassandra. Laissez-le terminer le travail et rafraîchissez la page (partez et préparez une tasse de thé - en 60 minutes, il aura certainement fait quelques chiffres).
Copyright (C) 2016 Dan Hassan
Conçu, développé et maintenu par Dan Hassan [email protected]
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
Dépendances du service API
https://github.com/scalatra/scalatra
Copyright (c) Alan Dipert [email protected]. Tous droits réservés.
Dépendances du service frontal
https://github.com/gaearon/react-redux-universal-hot-example
La licence MIT (MIT), Copyright (c) 2015 Erik Rasmussen
dépendances nœud-api
https://github.com/nodejs/node/blob/master/LICENSE
Copyright Contributeurs Node.js. Tous droits réservés.
openblockchainDépendances du service
https://github.com/docker/docker
Licence Apache, version 2.0, janvier 2004, http://www.apache.org/licenses/
Dépendances du service de scanner
https://github.com/outworkers/phantom
Copyright 2013-2016 Websudos, Limitée. , Tous droits réservés.
Dépendances du service Spark
https://github.com/apache/spark
Licence Apache, version 2.0, janvier 2004, http://www.apache.org/licenses/
