openblockchain
1.0.0
Das Projekt ist in mehrere Dienste aufgeteilt:
Jeder Dienst enthält einen oder mehrere Container und kann unabhängig voneinander skaliert werden.
Alle Docker-Images werden gehostet: https://hub.docker.com/u/openblockchaininfo/
Die folgenden Anweisungen führen Sie durch die Installation der gesamten Openblockchain-Anwendung, einschließlich aller Systemabhängigkeiten und Anforderungen, sodass Sie OpenBlockchain auf den meisten Basissystemen (Linux, OSX, Windows) ausführen können.
Die Anweisungen führen Sie zunächst durch die Installation von Ubuntu auf VirtualBox.
Aufgrund der Anforderungen an Rechenleistung und Speicherplatz wurde die Datenspeicherung und -verarbeitung für das Projekt so konzipiert, dass sie auf mehreren Computern ausgeführt wird, vorzugsweise in einer Cloud mit lokaler Verwaltung von einem Host-Computer aus.
Die folgenden Anweisungen führen Sie durch die Einrichtung Ihres Host-Computers mit Ubuntu und Docker-Engine, Docker-Machine und Docker-Compose.
Zuerst müssen Sie VirtualBox installieren, indem Sie diese Anweisungen befolgen
Anschließend müssen Sie Ubuntu 16.04.1 LTS – 64 Bit herunterladen, indem Sie diesen Anweisungen folgen
Sie müssen mit VirtualBox eine neue virtuelle Maschine erstellen. Die virtuelle Maschine (im Folgenden als „Hostmaschine“ bezeichnet) wird zur Bereitstellung der Anwendung verwendet. Der Host-Computer benötigt:
Wenn Sie den Host-Rechner zum ersten Mal starten, wählen Sie Ubuntu 16.04.1 LTS – 64 Bit (das Sie im vorherigen Schritt heruntergeladen haben) als Startvolume aus (es ist möglich, das Projekt auf anderen Versionen von Ubuntu und sogar anderen auszuführen). Betriebssysteme wie Windows und OS
Der Host-Computer wird nur zum Senden von Befehlen an den Cluster verwendet.
Die Cluster-Maschinen (auf denen die Dienste bereitgestellt werden) erfordern (jeweils):
Sobald Sie die Host-Maschine eingerichtet haben (siehe den folgenden Abschnitt „Voraussetzungen“), führen Sie die Anweisungen zur „Cluster-Einrichtung“ durch die Schritte, die zum Erstellen von drei Maschinen auf Scaleway erforderlich sind.
Diese dürfen nur auf dem Host-Computer installiert werden. Stellen Sie sicher, dass auf Ihrem Host-Rechner Ubuntu installiert ist (was Sie tun werden, wenn Sie die vorherigen Schritte befolgt haben).
1. Installieren Sie die Docker Engine
Docker Engine beinhaltet den Docker-Client. docker wird für die Kommunikation mit den Docker-Daemons verwendet, die auf jeder Maschine im Cluster ausgeführt werden.
Paketinformationen aktualisieren. Stellen Sie sicher, dass APT mit der https-Methode funktioniert und dass CA-Zertifikate installiert sind:
$ sudo apt-get update
$ sudo apt-get install apt-transport-https ca-certificates
Fügen Sie den offiziellen GPG-Schlüssel und das APT-Repository hinzu:
$ 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
Aktualisieren Sie den APT-Paketindex und installieren Sie Docker:
$ sudo apt-get update
$ sudo apt-get install docker-engine
Starten Sie den Docker-Daemon und überprüfen Sie, ob er korrekt installiert ist:
$ sudo service docker start
$ sudo docker run hello-world
Stets aktuelle Anleitungen finden Sie unter docker.com.
2. Installieren Sie Docker Machine
docker-machine wird verwendet, um Maschinen für den Cluster bereitzustellen.
Laden Sie die Docker Machine 0.8-Binärdatei herunter und extrahieren Sie sie in Ihren 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
Überprüfen Sie die Installation, indem Sie die Maschinenversion anzeigen:
$ docker-machine version
Stets aktuelle Anleitungen finden Sie unter docker.com.
3. Installieren Sie Docker Compose
Zur Verwaltung der Dienste wird Docker Compose verwendet.
$ 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
Überprüfen Sie die Installation, indem Sie die Compose-Version anzeigen:
$ docker-compose --version
Stets aktuelle Anleitungen finden Sie unter docker.com.
Sie haben jetzt Ihren Host-Computer konfiguriert. Du hast:
Auf diese Weise können Sie alle Microservices, aus denen die OpenBlockchain-Anwendung besteht, vom Host-Computer aus verwalten.
Die folgenden Anweisungen führen Sie durch die Bereitstellung des Clusters in der Cloud mithilfe von Scaleway. Der Cluster wird die folgenden Dienste enthalten:
Die Microservices werden über Docker-* auf Ihrem Host-Rechner verwaltet.
1. Erstellen Sie den Erkennungsdienst
Verwenden von Scaleway
Um Scaleway nutzen zu können, müssen Sie zunächst den Scaleway-Treiber für Docker Machine installieren:
$ 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
Erstellen Sie eine Maschine zum Hosten eines Consul-Erkennungsdienstes:
$ 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
Richten Sie Ihren Docker-Client auf die neue Maschine:
$ eval $(docker-machine env obc-consul)
Erstellen und starten Sie den Dienst:
$ 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. Starten Sie den Docker Swarm (Cluster)
Verwenden von Scaleway
Sie können die Maschinen von Scaleway bereitstellen, das erschwingliche High-End-Server bereitstellt, die perfekt für dieses Projekt geeignet sind.
Holen Sie sich Ihre Scaleway-Anmeldeinformationen (Zugriffsschlüssel und geheimer Schlüssel) auf dieser Seite und stellen Sie dann drei Maschinen bereit:
$ 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
Standardmäßig verfügen die Scaleway-Maschinen über eine 50-GB-Festplatte. Allerdings legt Scaleway auch eine 250-GB-SSD bei, die manuell gemountet werden muss:
$ 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' ;"
Dieser zusätzliche Speicher ist in der Benutzeroberfläche Ihres Scaleway-Kontos nicht sichtbar. Sie können manuell überprüfen, ob der zusätzliche Speicher bereitgestellt wurde (in diesem Fall obc):
$ docker-machine ssh obc
$ cat /etc/fstab
$ ls -al /openblockchain
3. Überprüfen Sie den Schwarm
Richten Sie Ihre Docker-Umgebung auf die Maschine, auf der der Schwarmmaster ausgeführt wird:
$ eval $(docker-machine env --swarm obc)
Cluster-Info drucken:
$ docker info
Sie können auch die IPs auflisten, die Consul „entdeckt“ hat:
$ docker run --rm swarm list consul://`docker-machine ip obc-consul`:8500
1. Erstellen Sie das Standardnetzwerk
Erstellen Sie ein Overlay-Netzwerk, das es Containern ermöglicht, sich gegenseitig zu „sehen“, unabhängig davon, auf welchem Knoten sie sich befinden:
$ docker network create --driver overlay --subnet 10.0.9.0/24 obcnet
Alle Netzwerke auflisten, obcnet sollte als overlay angezeigt werden:
$ docker network ls
openblockchain wurde mit mehreren Microservices entwickelt, die in der Haupt-Docker-Engine als Git-Submodule verknüpft sind.
Der folgende Befehl klont das Projekt und alle erforderlichen Gitmodule.
$ git clone --recursive https://github.com/open-blockchain/openblockchain.git
Nachdem Sie das Repo geklont haben, stellen Sie sicher, dass Sie in das Verzeichnis wechseln.
$ cd openblockchain
2. Auf!
Führen Sie im Stammordner (der docker-compose.yml enthält) Folgendes aus:
$ docker-compose up -d --build
Docker stellt alle Dienste bereit. Standardmäßig wird Folgendes gestartet:
3. Überprüfen Sie die Dienste
Alle Container und deren Status anzeigen (sie sollten alle „Up“ sein):
$ docker-compose ps
Zeigen Sie den Status des Cassandra-Clusters an (Sie sollten 3 Knoten sehen):
$ docker-compose exec cassandra-seed nodetool status
Inzwischen sollte der Bitcoin-Server bereits einige hundert Blöcke gescannt haben. Sehen wir es uns live an:
$ docker-compose logs -f --tail 100 bitcoin
Sie sollten etwa Folgendes sehen, was bedeutet, dass alle Blöcke von 0 bis 187591 heruntergeladen wurden (in diesem Beispiel):
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)
Sehen wir uns nun die Spark-Dashboards an, die derzeit leer sein sollten. Führen Sie den folgenden Befehl aus, um die Dashboard-URL jedes Spark-Masters und -Workers abzurufen:
$ 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. Scannen Sie die Blockchain
Protokolle der Scanner anzeigen:
$ docker-compose logs -f --tail 100 scanner-01
$ docker-compose logs -f --tail 100 scanner-02
Die Scanner wurden (in docker-compose.yml ) so konfiguriert, dass sie einen festen Blockbereich indizieren. Zu Beginn jedoch, wenn der Bitcoin-Knoten Block 330.000 noch nicht erreicht hat, kann scanner-02 (der für das Scannen von Blöcken von 330.000 bis 400.000 konfiguriert ist) nichts scannen. Daher wird 10 Minuten gewartet und es dann erneut versucht, bis diese Blöcke verfügbar sind.
2. Spark-Analyse
Der spark-submit -Dienst führt stündlich mehrere Spark-Skripte aus. Diese Skripte generieren Visualisierungen (d. h. Datenpunkte), die die API dem Frontend bereitstellt. Sie können den Fortschritt anhand der Protokolle verfolgen:
$ docker-compose logs -f --tail 100 spark-submit
Lassen Sie uns ein benutzerdefiniertes Skript ausführen, das alle Blöcke und Transaktionen in Cassandra zählt:
$ docker-compose exec spark-submit sbt submit-Counter
Wenn das Skript abgeschlossen ist, sollten Sie etwa Folgendes sehen (ignorieren Sie die Protokolle, die mit einem Zeitstempel beginnen):
Blocks: 239699
Transactions: 18941698
3. Greifen Sie auf die API zu
Suchen Sie den Namen des Computers, auf dem der API-Container ausgeführt wird:
$ docker ps --filter "name=node-api" --format "{{.Names}}"
Dadurch wird etwas wie obc-02/api ausgegeben, wobei der Teil vor dem Schrägstrich der Maschinenname ist.
Rufen Sie nun die URL der API ab und ersetzen Sie <machine-name-from-above> entsprechend:
$ echo "http://"`docker-machine ip <machine-name-from-above>`":10010"
4. Greifen Sie auf das Web-App-Frontend zu
Suchen Sie den Namen des Computers, auf dem der Frontend-Container ausgeführt wird:
$ docker ps --filter "name=frontend" --format "{{.Names}}"
Dadurch wird etwas wie obc-01/frontend ausgegeben, wobei der Teil vor dem Schrägstrich der Maschinenname ist.
Rufen Sie nun die URL des Frontends ab und ersetzen Sie <machine-name-from-above> entsprechend:
$ echo "http://"`docker-machine ip <machine-name-from-above>`":80"
5. Visualisierungen
Abhängig davon, ob der spark-submit -Dienst Zeit hatte, die Spark-Skripte fertigzustellen oder nicht, werden möglicherweise Visualisierungen im Frontend unter http://<frontend-ip>:80/blocks angezeigt.
Wenn Visualisierungen noch nicht verfügbar sind, überprüfen Sie den Fortschritt von spark-submit :
$ docker-compose logs -f --tail 100 spark-submit
Wenn er im Leerlauf ist, starten Sie den Dienst neu ( docker-compose restart spark-submit ). Andernfalls werden wahrscheinlich Daten von Cassandra verarbeitet. Lassen Sie es die Arbeit beenden und aktualisieren Sie die Seite (gehen Sie weg und kochen Sie eine Tasse Tee – in 60 Minuten werden sicherlich einige Zahlen ermittelt sein).
Copyright (C) 2016 Dan Hassan
Entworfen, entwickelt und gepflegt von 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/>.
API-Service-Abhängigkeiten
https://github.com/scalatra/scalatra
Urheberrecht (c) Alan Dipert [email protected]. Alle Rechte vorbehalten.
Frontend-Dienstabhängigkeiten
https://github.com/gaearon/react-redux-universal-hot-example
Die MIT-Lizenz (MIT), Copyright (c) 2015 Erik Rasmussen
Knoten-API-Abhängigkeiten
https://github.com/nodejs/node/blob/master/LICENSE
Copyright der Node.js-Mitwirkenden. Alle Rechte vorbehalten.
openblockchain-Dienstabhängigkeiten
https://github.com/docker/docker
Apache-Lizenz, Version 2.0, Januar 2004, http://www.apache.org/licenses/
Abhängigkeiten vom Scannerdienst
https://github.com/outworkers/phantom
Copyright 2013-2016 Websudos, Limited. , Alle Rechte vorbehalten.
Spark-Dienstabhängigkeiten
https://github.com/apache/spark
Apache-Lizenz, Version 2.0, Januar 2004, http://www.apache.org/licenses/
