Ethereum auf Docker

 

Die Ethereum Clients, wie hier geth, entwickeln sich derzeit rasend schnell. So schnell, das die Anleitung hier auch schon nicht mehr aktuell ist. Mit der aktuellen geth Version 1.5.9 kann Alpine hier nicht mehr als Basis genutzt werden. Es wird eine libusb Library benötigt die es jedoch unter UBUNTU gibt. Nachteil ist, das nun das neue Zielimage 230MB groß geworden ist.

 

Blockchain ist derzeit ein top aktuelles Thema. Banken, Versicherungen, Internet der Dinge, Energie- und Verkehrsunternehmen versuchen sich an dem Thema.
Einen ersten verständlichen Erklärungsversuch findet man hier:

https://www.it-finanzmagazin.de/

Was man damit alles machen kann scheint schon phantastisch. Doch was wirklich dran ist und welche Möglichkeiten damit eröffnen zeigt sich erst im ersten praktischen Einsatz.
Was man dazu braucht ? Eine private Blockchain die hier mit Hilfe von Docker auf einem Raspberry Pi Cluster erzeugt wird.

Docker Image erstellen

Damit Ethereum genutzt werden kann wird zunächst ein Ethereum Client benötigt. Dieser wird hier in einem Docker Image erstellt und läuft später im Raspberry Pi Cluster.

Damit das neue Image möglichst klein gehalten wird, erfolgt die Erstellung in einem RUN Step. So bleibt das neue Image bei < 60MB ! Von Versuchen, das Source Verzeichnis mit ADD in das Image zu Linken kann abgeraten werden. Alle Versuche landen bei über 700MB.

Zur Erstellung folgenden Inhalt in das File „Dockerfile-alpine“ kopieren:

FROM alpine:3.3

RUN apk update && \
apk add git go gcc make musl-dev nano && \
git clone https://github.com/ethereum/go-ethereum && \
cd go-ethereum && \
make geth && \
mv build/bin/geth / && \
apk del gcc go make musl-dev && \
rm -rf /go-ethereum && \
rm -rf /var/cache/apk/*

#EXPOSE 8545
#EXPOSE 30303

ENTRYPOINT /bin/sh

(Alternative ist zu empfehlen, ein eigenes Basis Image zu erstellen als ein Image zu Docker Hub zu laden)

Das Image dann mit

docker build -f Dockerfile-alpine -t micsen/ethereum-alpine:v1 .

erstellen und zum Test einmal starten mit

docker run -it micsen/ethereum-alpine:v1

Im Prompt den eigentlichen Ethereum Client mit „./geth“ starten:

Das Docker Image besitzt nun den benötigten Ethereum Client. Damit dieses Image nun im gesamten LAN zur Verfügung steht muß es noch um die Server Adresse umbenannt und in die Registry geladen werden:
(Dieser Schritt kann übersprungen werden, wenn man das Image nicht auf einem anderen System zur Verfügung stellen will.)

docker tag micsen/ethereum-alpine:v1  <REG SERVER>:<PORT>/ethereum-alpine:v1

docker push <REG SERVER>:<PORT>/ethereum-alpine:v1

Der letzte Aufruf transportiert schließlich das Docker Image in das private Registry und ist dann LAN weit zu erreichen. Weitere Schritte sind nun auf dem gleicher Server oder auf einem andere sog. Node durchzuführen.

Erzeugen privater Blockchains

Zum erzeugen privater Blockchains wird ein allererster Block ‚0‘ erzeugt, dieser sog. Genesis Block wird wie folgt definiert:

{„nonce“: „0x0000000000000068“,
„mixhash“: „0x0000000000000000000000000000000000000000000000000000000000000000“,
„difficulty“: „0x4000“,
„alloc“: {},
„coinbase“: „0x0000000000000000000000000000000000000000“,
„timestamp“: „0x00“,
„parentHash“: „0x0000000000000000000000000000000000000000000000000000000000000000“,
„extraData“: „Custom Ethereum Genesis Block“,
„gasLimit“: „0xffffffff“}

Dies Daten in einer einfachen Textdatei mit dem Namen genesis.json speichern.

Zunächst wird ein neues Verzeichnis benötigt in der die privaten Ethereum Daten gespeichert werden so. Diese liegen bei mir in einem Netzlaufwerk welches mit

sudo mount -t nfs 10.0.0.150:/nfs/ethereum/ /var/ethereum

netzwerkseitig gemountet wird.

Der eigentliche Container in dem der Ethereum Client läuft wird gestartet mit

docker run -it -v /var/ethereum/mychain/:/ethData -v /home/pirate/ethereum/:/root/ dockerserver:5000/ethereum-alpine:v1

oder mit Ports

docker run -it -v /var/ethereum/mychain/:/ethData -v /home/pirate/ethereum/:/root/ -p 8545:8545 -p 30303:30303  dockerserver:5000/ethereum-alpine:v1

oder allgemein

docker run -it -v <HOST PATH>:/ethData -v <LOCAL PATH>:/root/ -p <LOCAL PORT>:<CONTAINER PORT> ethereum-alpine:v1

 

Hierbei wird das gemountete ethData Verzeichnis  und das lokale Verzeichnis mit dem Container verbunden. Nach dem Start erscheint nur eine Bash Aufforderung.

Um die lästige Eingabe des Passworts zu vermeiden wird ein Flat Password-File benötigt. Diese einfach unter dem privaten Ethereum Verzeichnis erstellt:

mkdir /ethData/etc
sudo echo dasganzsollgeheimsein123!  > /ethData/etc/passwordfile

Der Konto (Konto-Hash) für das hinterlegte Passwort wir dann mit

/geth –datadir /ethData \
–password /ethData/etc/passwordfile \
account new

erstellt.

Wichtig hier ist die Angabe des Data Directorys. Dieses ist durch den Container Aufruf in das entsprechende Verzeichnis gemountet. Daher ist innerhalb des Container hier immer /ethData anzusprechen. Dies vereinfacht später die Nutzung unterschiedlicher private und public Ethereum Blockchains. Entsprechendes gilt auch für den Aufruf für die Console:

 geth –datadir /ethData –dev –nodiscover \
–mine –minerthreads 1 –maxpeers 0 –verbosity 3 \
–unlock 0 –password /ethData/etc/passwordfile \
–rpc console

Nach dem Aufruf folgt:

und kurze Zeit später wird bereits private Ether erzeugt:

mit

balance = web3.fromWei(eth.getBalance(eth.accounts[0]), „ether“);

wird das geschürfte in der Währung Ether ausgegeben.

Nach 30min waren dies schon 450 Ether. Dies sind private Ether die nur für den Blockchain Besitzer einen Wert haben !

In diesem Fall zum erstellen erster Contract Apps.

http://solidity.readthedocs.io/en/latest/

https://de.wikipedia.org/wiki/Solidity

 

http://dapps.ethercasts.com/

How to build server less applications for Mist

 

 

Dieser Beitrag wurde unter Docker & Container veröffentlicht. Setzen Sie ein Lesezeichen auf den Permalink.

Ein Kommentar zu Ethereum auf Docker

  1. GK sagt:

    Super Recherche. Danke für den Artikel

Schreiben Sie einen Kommentar

Ihre E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert.