Wie installiere ich einen Cardano Node?

Tutorial: Version 1.19.0

In diesem Tutorial zeigen wir dir wie man einen Cardano Node installiert. Dazu benötigst du lediglich einen Server. Du kannst diesen Server lokal bei dir oder auf einem alten PC laufen lassen. Wir empfehlen aber dir einen Server bei einem Hostingprovider (Google Cloud, Amazon Aws etc..) zu mieten. Die kosten hierfür sind relativ gering. Wichtig: Die Befehle in diesem Tutorial sind für Ubuntu. Wenn du eine andere Linux Distribution verwendest passe die Befehle bitte an.

Server auf Google Cloud bereitstellen

Um einen Cardano Node laufen zu lassen benötigen wir einen Server. In unserem Tutorial werden wir einen Server aus der Google Cloud verwenden.

Melde dich auf Google Cloud an und lege eine VM-Instanz an. Wir werden eine aktuelle Ubuntu Distribution wählen.

Wähle “Erstellen” um eine VM-Instanz zu erstellen.

Passe deinen Server nun entsprechend deiner Anforderungen an. Wir werden hier die Mindestanforderungen wählen. 4 GB RAM 10 GB Festplattenspeicher.

So. Nun haben wir die VM-Instanz mit Linux installiert. Vergiss nicht, wir bewegen uns nicht auf grafischen Benutzeroberflächen. Diese gibt es bei Ubuntu Desktop Distributionen, aber nicht bei den Serverinstallationen. Wenn du gar nicht damit klar kommst kannst du manuell eine GUI installieren.

SSH-Keys generieren

Wir wollen un nun über SSH von unserem lokalen Computer auf den remote Server verbinden. Dazu müssen wir in Putty oder in unserem Fall Mobaxterm ein SSH Schlüsselpaar generieren. Den Public Key legen wir in der Google Konsole ab und den Private Key speichern wir lokal oder auf einem USB-Stick. Dazu öffnen wir Mobaxterm und führen folgenden Befehl aus:

ssh-keygen

Prüfe mit ls ob Keys generiert wurden. Mit vi kannst du die Keys ansehen.

Privater Schlüssel lokal speichern

Wenn privater und öffentlicher Schlüssel generiert wurden kannst du privaten Schlüssel in eine Textdatei kopieren und an einem nur dir bekannten Ort abspeichern. Hierzu eignet sich ein USB-Stick.Bedenke, dass du den Schlüssel zur Anmeldung über SSH bereitstellen musst.

Öffentlicher Schlüssel in Google Cloud Konsole ablegen

Den öffentlichen Schlüssen kopierst du in das entsprechende Eingabefeld in der Google Cloud Console. Achte darauf, dass du den Name des PCs mit dem Namen deiner Gmail-Adresse ersetzt (alles exclusive @…).

Serverzugriff einrichten

Um auf unseren Server von unserem lokalen PC oder Laptop auf den entfernten Server zuzugreifen kannst du dein Windows Terminal, Putty oder Mobaxterm verwenden. Wir verwenden wie gesagt Mobaxterm, da dies ein angenehmes Tool ist, welches auch einen FTP Client integriert hat falls man später Keys und Wallets verschieben möchte. In unseren anderen Tutorials zeigen dir wie man den Standardport 22 ändert und wie man andere sicherheitsspezifischen Anpassungen macht.

Root-User aktivieren

Wir werden die komplette Installation des Cardano Nodes mit dem root User machen. Diesen aktivieren wir in dem wir ihm ein Kennwort vergeben. Mit su root wechselst du anschließend zum Root User.

sudo passwd root

Abhängigkeiten installieren

Um Cardano-Node und Cardano-Cli zu installieren benötigen wir folgende Abhängigkeiten. Du installierst diese mit folgendem Befehl (Ubuntu):

sudo apt-get update -y

sudo apt-get install automake build-essential pkg-config libffi-dev libgmp-dev libssl-dev libtinfo-dev libsystemd-dev zlib1g-dev make g++ tmux git jq wget libncursesw5 libtool autoconf -y

Je nachdem wie gut du mit dem vorhandenen Linux Texteditor vi klarkommst kannst du zusätzlich noch nano installieren.

sudo apt-get install nano

Cabal installieren

wget https://downloads.haskell.org/~cabal/cabal-install-3.2.0.0/cabal-install-3.2.0.0-x86_64-unknown-linux.tar.xz
tar -xf cabal-install-3.2.0.0-x86_64-unknown-linux.tar.xz
rm cabal-install-3.2.0.0-x86_64-unknown-linux.tar.xz cabal.sig
mkdir -p ~/.local/bin
mv cabal ~/.local/bin/

Stelle sicher, dass sich .local/bin in deinem Pfad befindet. Gib dazu echo $PATH in die Kommandozeile ein. Wenn diese nicht der Fall ist füge die folgende Zeile ans Ende der Datei .bashrc ein und prüfe die Pfadvariable anschließend erneut:

export PATH="~/.local/bin:$PATH"

sowie sourcen:

source .bashrc

Wenn du die Pfadvariable korrekt gesetzt hast solltest du nun aus jedem Verzeichnis heraus Cabal verwenden können. Du kannst den Pfad prüfen indem du echo $PATH ausführst. Der Pfad sollte dann ausgegeben werden. Prüfe mit folgendem Befehl, ob Cabal korrekt installiert wurde.

cabal --version

GHC installieren

wget https://downloads.haskell.org/~ghc/8.6.5/ghc-8.6.5-x86_64-deb9-linux.tar.xz
tar -xf ghc-8.6.5-x86_64-deb9-linux.tar.xz
rm ghc-8.6.5-x86_64-deb9-linux.tar.xz
cd ghc-8.6.5
./configure
sudo make install

Das herunterladen und entpacken kann mehrere Minuten dauern. Navigiere anschließend mit cd zurück ins Homeverzeichnis. Wir sollten nun einen Ordner ghc-8.6.5 haben.

Libsodium installieren

git clone https://github.com/input-output-hk/libsodium
cd libsodium
git checkout 66f017f1
./autogen.sh
./configure
make
sudo make install

Anschließend kannst du wieder zurück in das Homeverzeichnis navigieren. Warnungen bei der Installation sollten dich nicht beunruhigen. Nur wenn du Error Bekommst musst du nochmal prüfen ob du soweit alle Schritte korrekt durchgeführt hast. Nachdem wir Libsodium installiert haben füge wie vorhin folgende zwei Zeilen in die .bashrc Datei und source die Datei wieder. Prüfe die Pfadvariablen.

export LD_LIBRARY_PATH="/usr/local/lib:$LD_LIBRARY_PATH"
export PKG_CONFIG_PATH="/usr/local/lib/pkgconfig:$PKG_CONFIG_PATH"

Download und Installation Cardano-Node und Cardano-Cli

Jetzt kommen wir zum interessanten Teil der Installation des Cardano Nodes. Im Homeverzeichnis führen wir folgenden Befehl aus um den aktuellen Sourceordner von Github herunterzuladen:

git clone https://github.com/input-output-hk/cardano-node.git

Navigiere in den Ordner cardano-node

cd cardano-node

Checke die neueste Version aus Github aus:

git fetch --all --tags
git tag
git checkout tags/<TAGGED VERSION> 

(Beispiel: git checkout tags/1.19.0)

Stell sicher, dass du regelmäßig die neueste Version auscheckst. IOHK ist sehr fleißig und commited manchmal mehrmals die Woche einen neuen neuen Release. Für dich bedeutet das folgendes: Du checkst immer die aktuellste version aus, es sei denn IOHK meldet, dass es Bugs gibt und rät vorerst auf der alten Version zu bleiben bis es Bugfixes gibt. Bedeutet, wenn du dieses Tutorial durchgehst und mittlerweile die Version 1.28.4 und 1.29.0 veröffentlicht wurden wählst du die 1.29.

Cardano-Node builden und installieren

Bevor du den Node installierst empfiehlt es sich die neuesten cabal Packages herunterzuladen. Dadurch lassen sich sporadisch auftretenden Fehler bei der Installation vermeiden.

cabal update

Anschließend kann die Installation des Nodes gestartet werden.

cabal build all

Das builden kann durchaus eine bis zwei Stunden dauern. Wenn das builden nur 15 Minuten dauert, dann bitte prüfen ob es Fehlermeldungen gab. Eventuell nochmal builden. Anschließend die Verzeichnisse für cardano-node und cardano-cli kopieren:

cp -p dist-newstyle/build/x86_64-linux/ghc-8.6.5/cardano-node-<TAGGED VERSION>/x/cardano-node/build/cardano-node/cardano-node ~/.local/bin/

cp -p dist-newstyle/build/x86_64-linux/ghc-8.6.5/cardano-cli-<TAGGED VERSION>/x/cardano-cli/build/cardano-cli/cardano-cli ~/.local/bin/

Hinweis: Wenn du ein Update durchführst machst du genau dasselbe. Du checkst die neueste Version aus, buildest mit cabal build all und kopierst die Verzeichnisse. Hier kommt es gelegentlich vor, dass der Node anschließend nicht mehr korrekt synct. Dann lösche einfach den db Ordner. (Später mehr)

Nun überprüfe ob cardano-node und cardano-cli richtig installiert worden sind:

cardano-cli --version
und
cardano-node --version

Gratuliere, du hast deinen ersten Cardano Node installiert. Müssen wir ihn nur mehr konfigurieren und können ihn starten.

Konfigurationsdateien herunterladen und anpassen

Nun müssen wir die Konfigurationsdateien für den Node installieren. Prüfe, dass du immer die aktuellsten Dateien herunterlädst. Am besten navigierst du mit dem Browser zu den Dateien und stellst sicher, dass es die aktuellsten sind. Du kannst ansonsten auch in der offiziellen Cardano Doku nachsehen.

Mach am besten im Homeverzeichnis einen Ordner “nodes” und darin ein Verzeichnis “block-producing”. Navigiere in das Verzeichnis block-producing und lade die Konfigurationsdateien herunter. Wenn du in weiterer folge andere Nodes erstellst kannst du diese in einem Ordner “relay1” abspeichern. Wir empfehlen aber ohnehin jeden Node auf einem eignen Server zu rennen.

wget https://hydra.iohk.io/job/Cardano/cardano-node/cardano-deployment/latest-finished/download/1/mainnet-config.json
wget https://hydra.iohk.io/job/Cardano/cardano-node/cardano-deployment/latest-finished/download/1/mainnet-byron-genesis.json
wget https://hydra.iohk.io/job/Cardano/cardano-node/cardano-deployment/latest-finished/download/1/mainnet-shelley-genesis.json
wget https://hydra.iohk.io/job/Cardano/cardano-node/cardano-deployment/latest-finished/download/1/mainnet-topology.json

Wenn du die Dateien heruntergeladen öffne die mainnet-topology.json und bearbeite diese entsprechend deiner Topologie.

{
  "Producers": [
    {
      "addr": "x.x.x.x",
  //deine öffentliche (statische) IP-Adresse
      "port": 3001,
       //der Port deines Relay Nodes. 
      "valency": 2
        // Wenn du mehrere Relay Nodes hast setze die Valancy auf 2. 
    }
  ]
}

Beachte, dass du hier deinem Block-Producing Node sagst mit wem er kommunizieren soll. Du gibst also hier den Port des Relays an. Wenn du mehrere Relays hast hast du mehrere dieser Einträge. Wichtig: Der Block-Producing Node kommuniziert NUR mit deinen Relays. Mit nichts anderem.

Beispiel Block-Produzierender Node
{
  "Producers": [
    {
      "addr": "81.82.83.84",
      "port": 3001,
      "valency": 2
    },
    {
      "addr": "71.72.73.74",
      "port": 3002,
      "valency": 2
   
    }
  ]
}

Beispiel Relay1 Node
 mit 81.82.83.84 /3001
{
  "Producers": [
    {
      "addr": "61.62.63.64", // Kommunikation mit Block-Producing Node
      "port": 3000,
      "valency": 2
    },
    {
      "addr": "relays-new.cardano-mainnet.iohk.io"",
 // Kommunikation mit dem Relay von IOHK
      "port": 3002,
      "valency": 2
        
    }
  ]
}

Node starten

Wir haben in den letzten Schritten die Abhängigkeiten, Cardano-Node und Cardano-Cli installiert. Desweiteren haben wir die Konfigurationsdateien für den Node heruntergeladen und angepasst. Jetzt können wir den Node starten. Da wir den Block-Producing Node konfiguriert haben wollen wir diesen auch starten. Diesen starten wir über Port 3000. Wenn wir weitere Relays hinzufügen konfigurieren wir diese übersichtshalber über 300n+1. (Relay1 -> 3001, Relay2 -> 3002). Theoretisch kannst du diese auch alle auf dem selben Port laufen lassen, da diese ja auf eigenen Rechnern laufen.

  cardano-node run \
   --topology path/to/mainnet-topology.json \
   --database-path path/to/db \
   --socket-path path/to/db/node.socket \
   --host-addr x.x.x.x \
   --port 3001 \
   --config path/to/mainnet-config.json

An unser Beispiel angepasst ist das folgender Befehl:

cardano-node run \
   --topology ~/nodes/block-producing/mainnet-topology.json \
   --database-path ~/nodes/block-producing/db \
   --socket-path ~/nodes/block-producing/db/node.socket \
   --host-addr 61.62.63.64 \
   --port 3000 \
   --config ~/nodes/block-producing/mainnet-config.json

Pfadvariable setzen: Falls der cardano-node run Befehl nicht erkannt wird setze bitte den Pfad in der .bashrc Datei (siehe oben) und source sie neu.

export CARDANO_NODE_SOCKET_PATH=path/to/db/node.socket

an unseren Block-Producing Node angepasst:

export CARDANO_NODE_SOCKET_PATH=~/nodes/block-producing/db/node.socket

Gratuliere. Dein Block-Producing Node synchronisiert jetzt über Port 3000 die gesamte Cardano Blockchain. Dies kann mehrere Stunden dauern.