Erste Schritte mit Avalanche: Einen Node einrichten

Published in

avalanche_dach

8 min readFeb 6, 2021

Der englische Originalartikel dieser Übersetzung ist hier zu finden

Am schnellsten und einfachsten lernt man Avalanche kennen wenn man selber einen Node einrichtet und diesen in das Netzwerk integriert.

In diesem Tutorial (welches ungefähr 10 Minuten dauert) werden wir:

Einen Avalanche-Node einrichten und ausführen
Eine Verbindung zum Avalanche-Netzwerk herstellen
AVAX versenden
Unseren Node zu einem Validator-Set hinzufügen

Solltest du dabei Probleme haben und in den FAQs nicht die richtige Lösung dabei sein, dann schau einfach in unserem Avalanche Discord vorbei! Dort werden wir sicher gemeinsam eine Lösung für dein Problem finden.

Dieses Tutorial richtet sich in erster Linie an Entwickler und Personen, die daran interessiert sind, wie die Avalanche-Plattform funktioniert. Wenn du nur einen Node für das Staking einrichten möchtest, so solltest du stattdessen das Tutorial “Set Up Avalanche Node With Installer” verfolgen. Der Installer automatisiert den Installationsprozess und richtet den Node als Systemdienst ein, was für den unbeaufsichtigten Betrieb empfohlen wird. Du kannst aber auch die verschiedenen Funktionalitäten von Avalanche zuerst ausprobieren, indem du dieses Tutorial abarbeitest und den Node dann später mit dem Installer dauerhaft einrichtest.

Systemanforderungen

Avalanche ist ein sehr leichtgewichtiges Protokoll, daher sind die Mindestanforderungen an dein System recht gering:

Hardware: CPU > 2 GHz, RAM > 4 GB, Speicher > 10 GB freier Platz
OS: Ubuntu 18.04/20.04 oder MacOS >= Catalina

Starten eines Avalanche-Nodes und versenden von AVAX

Wir installieren nun AvalancheGo, die Go-Implementierung eines Avalanche-Node, und verbinden wir uns mit dem Avalanche Public Testnet.

AvalancheGo herunterladen

Der Node selbst wird als Binary betrieben. Du kannst entweder den Quellcode herunterladen und dann das ausführbare Binary selbst erstellen, oder du lädst dir einfach das fertigte Binary herunter. Es ist aber nicht notwendig beides zu tun.

Das Herunterladen des vorgefertigten Binaries ist einfacher und wird empfohlen, wenn du nur deinen eigenen Node ausführen und damit staken möchtest.

Das Erstellen des Nodes aus dem Quellcode wird empfohlen, wenn du Entwickler bist und mit Avalanche experimentieren und Applikationen für Avalanche bauen möchtest.

Source Code

Möchtest du den Node auf Basis des Quellcodes selber erstellen, so musst du dir zuerst Go 1.15.5 (oder eine aktuellere Version) installieren. Eine Anleitung dazu findest du hier.

Rufe nun go version auf. Hier muss mindestens Version 1.15.5 zurückgegeben werden. Führe anschließendecho $GOPATHaus, das Ergebnis darf nicht leer sein.

Wir laden uns nun das AvalancheGo Repository herunter:

go get -v -d github.com/ava-labs/avalanchego/...

Hinweis für erfahrene User: AvalancheGo verwendet Go modules, du kannst also das AvalancheGo Repository auch in andere Zielorte als deinen GOPATH klonen.

Wir wechseln nun in das avalanchego Verzeichnis:

cd $GOPATH/src/github.com/ava-labs/avalanchego

Abschließend bauen wir AvalancheGo mit folgendem Befehl:

./scripts/build.sh

Das Binary avalanchegofinden wir nun im Ordner avalanchego/build.

Binary

Wenn du dir lieber ein fertiges Binary herunterladen möchtest so findest du dieses auf der Releases Seite. Dort kannst du aus verschiedenen Releases wählen, unter anderem natürlich auch dem jeweils aktuellsten.

Unter Assetskannst du die jeweilige Datei auswählen.

Für MacOS:
Download: avalanchego-macos-<VERSION>.zip
Unzip: unzip avalanchego-macos-<VERSION>.zip
Der daraus resultierende Ordner, avalanchego-<VERSION>, enthält die benötigten Binaries.

Für Linux (PCs oder bei einem Cloud Service Provider):
Download: avalanchego-linux-amd64-<VERSION>.tar.gz
Unzip: tar -xvf avalanchego-linux-amd64-<VERSION>.tar.gz
Der daraus resultierende Ordner, avalanchego-<VERSION>-linux, enthält die benötigten Binaries.

Für Linux auf einem RaspberryPi4 oder vergleichbaren Arm64-basierten Systemen:
Download: avalanchego-linux-arm64-<VERSION>.tar.gz
Unzip: tar -xvf avalanchego-linux-arm64-<VERSION>.tar.gz
Der daraus resultierende Ordner, avalanchego-<VERSION>-linux, enthält die benötigten Binaries.

Den Node starten und mit dem Avalanche-Netzwerk verbinden

Wenn du die Binaries selber gebaut hast:

./build/avalanchego

Wenn du das fertige Binaries unter MacOS verwendest:

./avalanchego-<VERSION>/build/avalanchego

Wenn du das fertige Binaries unter Linux verwendest:

./avalanchego-<VERSION>-linux/avalanchego

Nach dem Start des Nodes befindet sich dieser im Bootstrap-Modus und muss sich zuerst mit dem Netzwerk synchronisieren. Du findest dazu auch entsprechende Logeinträge. Sobald der Bootstrap abgeschlossen ist wird folgende Meldung angezeigt:

INFO [06-07|19:54:06] <X Chain> /snow/engine/avalanche/transitive.go#80: bootstrapping finished with 1 vertices in the accepted frontier

Um zu prüfen, ob dein Node das Bootstrapping schon abgeschlossen hat, kannst du auch ein zweites Terminal-Fenster öffnen undinfo.isBootstrapped aufrufen indem du folgendes Kommando absetzt:

curl -X POST --data '{
    "jsonrpc":"2.0",
    "id"     :1,
    "method" :"info.isBootstrapped",
    "params": {
        "chain":"X"
    }
}' -H 'content-type:application/json;' 127.0.0.1:9650/ext/info

Wird hier truezurückgegeben so ist das Bootstrapping abgeschlossen. Setzt du hingegen API Aufrufe gegen eine Chain ab, die sich noch im Bootstrapping Modus befindet, so wirst die Meldung API call rejected because chain is not done bootstrappingerhalten. Beendet dein Node das Bootstrapping nicht, so kannst du diese FAQ befolgen. Hilft auch das nicht so kontaktierte uns bitte direkt in Discord.

Dein Node läuft nun also und ist mit dem Netzwerk verbunden. Möchtest du deinen Node als Validator im Mainnet verwenden so kannst du dieses Tutorial verwenden um herauszufinden, wie du deinen Node über das Web Wallet als Validator hinzufügen kannst.

Mittels STRG + C kannst du deinen Node jederzeit beenden.

Wenn du mit deinem Node noch weiter experimentieren willst kannst du das tun, indem du die hier beschriebenen weiteren Schritte durchspielst.

Möchtest du in der Lage sein API Aufrufe von anderen Rechnern gegen deinen Node absetzen zu können, so kannst du deinem Node folgendes Commandline-Argument beim Start mitgeben: --http-host= (z.B. ./build/avalanchego --http-host=)

Um deinen Node mit dem Fuji Testnet anstatt dem Mainnet zu verbinden kannst du den Befehl --network-id=fujiverwenden. Um Funds im Testnet zu erhalten benütze bitte das Faucet.

Einen Keystore-User erstellen

Der Avalanche Node hat direkt einen Keystore integriert. Der Keystore verwaltet die User und ist vergleichbar mit einem Wallet. Ein User ist eine Password-geschützte Entität welche ein Client für die Interaktion mit der Blockchain verwenden kann. Keystore-User dürfen nur auf jenen Nodes erstellt werden die du auch selbst betreibst, da ansonsten der Node-Betreiber Zugriff auf dein Passwort im Klartext erhält.

Um einen User zu erstellen wirdkeystore.createUseraufgerufen:

curl -X POST --data '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "keystore.createUser",
    "params": {
        "username": "YOUR USERNAME HERE",
        "password": "YOUR PASSWORD HERE"
    }
}' -H 'content-type:application/json;' 127.0.0.1:9650/ext/keystore

Der Response sieht folgendermaßen aus:

{
    "jsonrpc":"2.0",
    "result":{"success":true},
    "id":1
}

Der User auf diesem Node ist nun erstellt. Die Keystore-Daten existieren dabei auf Ebene des Nodes. User, die auf einem bestimmten Node erstellt werden, existieren nicht auf anderen Nodes, können aus einem Keystore aber exportiert und in einen anderen Keystore importiert werden. Details dazu findest du in der Keystore API.

Wichtig: Man sollte nur einen kleinen Teil der Funds auf dem Node belassen. Der größte Teil deiner Funds sollte durch eine Mnemonik gesichert werden, die am besten offline gespeichert ist.

Eine Adresse erstellen

Avalanche besteht aus heterogenen Blockchains, eine davon ist die so genannte X-Chain, welche als dezentrale Plattform für das Erstellen und Traden von digitalen Assets dient. Wir erstellen nun eine Adresse um damit unsere AVAX verwalten zu können.

Um eine neue Adresse auf der X-Chain zu erstellen rufen wir avm.createAddressauf, eine Methode der X-Chain API:

curl -X POST --data '{
    "jsonrpc":"2.0",
    "id"     :2,
    "method" :"avm.createAddress",
    "params" :{
        "username":"YOUR USERNAME HERE",
        "password":"YOUR PASSWORD HERE"
    }
}' -H 'content-type:application/json;' 127.0.0.1:9650/ext/bc/X

Ist dein Node noch nicht fertig mit dem Bootstrap, so wird dieser Aufruf den Status 503 mit folgender Nachricht zurückliefern: API call rejected because chain is not done bootstrapping.

Bitte beachte, dass wir diesen Aufruf gegen127.0.0.1:9650/ext/bc/X absetzen. Der Teil bc/X zeigt an, dass dieser Aufruf gegen die Blockchain gesendet wird, deren ID (oder Alias) X ist (also die X-Chain).

Der Response sollte folgendermaßen aussehen:

{
    "jsonrpc":"2.0",
    "id":2,
    "result" :{
        "address":"X-avax1xeaj0h9uy7c5jn6fxjp0rg4g39jeh0hl27vf75"
    }
}

Dein User hat nun Zugriff auf die AdresseX-avax1xeaj0h9uy7c5jn6fxjp0rg4g39jeh0hl27vf75 auf der X-Chain. Um die Adressen auf den verschiedenen Sub-Chains unterscheiden zu können gibt es in Avalanche die Konvention, dass eine Adresse die ID oder den Alias jener Chain beinhalten muss, auf der diese existiert. Daher beginnt unsere Adresse mit X- und zeigt damit an, dass diese auf der X-Chain existiert.

Funds von der Avalanche Wallet auf deinen Node senden

Achtung: Die folgende Anleitung versendet echte AVAX.

Wir senden nun Funds von unserer Avalanche Wallet auf unseren Node.

Wir öffnen nun das Avalanche Wallet. Klicke nun auf Access Wallet, anschließend auf Mnemonic Key Phrase. Gib nun bitte deinen Mnemonic Code ein.

Klicke nun auf den Send Tab im linken Menü. Unter Amount bitte .002 AVAX eintragen. Trage nun abschließend noch die Adresse deiner X-Chain ein und klicke auf Confirm.

Wir können nun die Balance eines bestimmten Assets auf unserer Adresse mit einem Aufruf gegen avm.getBalance ermitteln, welche eine weitere Methode der X-Chain API ist. Wir kontrollieren nun, ob unsere Überweisung funktioniert hat:

curl -X POST --data '{
    "jsonrpc":"2.0",
    "id"     :3,
    "method" :"avm.getBalance",
    "params" :{
        "address":"X-avax1xeaj0h9uy7c5jn6fxjp0rg4g39jeh0hl27vf75",
        "assetID"  :"AVAX"
    }
}' -H 'content-type:application/json;' 127.0.0.1:9650/ext/bc/X

Beachte, dass AVAX die spezielle ID AVAX besitzt. Typischerweise ist die die ID eines Assets eine alphanumerische Zeichenfolge.

Der Response sollte anzeigen, dass wir 2,000,000 nAVAX bzw.0.002 AVAX besitzen.

{
    "jsonrpc":"2.0",
    "id"     :3,
    "result" :{
        "balance":2000000,
        "utxoIDs": [
            {
                "txID": "x6vR85YPNRf5phpLAEC7Sd6Tq2PXWRt3AAHAK4BpjxyjRyhtu",
                 "outputIndex": 0
            }
        ]
    }
}

AVAX versenden

Wir versenden nun ein paar AVAX per Aufruf gegen unseren Node:

curl -X POST --data '{
    "jsonrpc":"2.0",
    "id"     :5,
    "method" :"avm.send",
    "params" :{
        "assetID"    :"AVAX",
        "amount"     :1000,
        "to"         :"X-avax1w4nt49gyv4e99ldqevy50l2kz55y9efghep0cs",
        "changeAddr" :"X-avax1turszjwn05lflpewurw96rfrd3h6x8flgs5uf8",
        "username"   :"YOUR USERNAME HERE",
        "password"   :"YOUR PASSWORD HERE"
    }
}' -H 'content-type:application/json;' 127.0.0.1:9650/ext/bc/X

amount zeigt an, wieviele nAVAX wir versenden.

Wenn du eine bestimmte Adresse angeben willst, wohin der Change (die “Wechselgebühr”) der Überweisung ausgezahlt werden soll, so kannst du diese unter changeAddrangeben, der Parameter kann aber auch leer gelassen werden. Wenn dem so ist, dann wird der Change auf eine der Adressen überwiesen, die dein User verwaltet.

Um Spam im Netzwerk zu verhindern verlangt Avalanche Transaktionsgebühren. Diese werden automatisch bei einer Transaktion von einer der Adressen abgezogen, die dein User verwaltet. Das solltest du beachten, wenn du nun die Balance prüfst.

Klicke bitte hier wenn du mehr über Transaktionsgebühren wissen möchtest

Wenn du diesen Request sendest authentifiziert dich der Node über den Usernamen und das dazugehörige Passwort. Anschließend werden alle Private Keys deines Users durchsucht bis genug AVAX gefunden wurden um die Transaktion durchführen zu können.

Der Response beinhaltet die Transactions-ID. dieser unterscheidet sich bei jedem Aufruf vonsend.

{
    "jsonrpc":"2.0",
    "id"     :5,
    "result" :{  
        "txID":"2QouvFWUbjuySRxeX5xMbNCuAaKWfbk5FeEa2JmoF85RKLk2dD",
        "changeAddr" :"X-avax1turszjwn05lflpewurw96rfrd3h6x8flgs5uf8"
    }
}

Überprüfen des Transaktionsstatus

Die Transaktion benötigt nur eine oder zwei Sekunden für die Finalisierung. Den Status können wir mit avm.getTxStatus überprüfen:

curl -X POST --data '{
    "jsonrpc":"2.0",
    "id"     :6,
    "method" :"avm.getTxStatus",
    "params" :{
        "txID":"2QouvFWUbjuySRxeX5xMbNCuAaKWfbk5FeEa2JmoF85RKLk2dD"
    }
}' -H 'content-type:application/json;' 127.0.0.1:9650/ext/bc/X

Der Response sollte anzeigen, dass die Transaktion akzeptiert wurde:

{
    "jsonrpc":"2.0",
    "id"     :6,
    "result" :{
        "status":"Accepted"
    }
}

Eventuell könnte es sein, dass der zurück gelieferte Status Processing lautet. Dies ist dann der Fall, wenn das Netzwerk die Transaktion noch nicht finalisiert hat.

Sobald die Transaktion im Status Accepted ist können wir die Balance der to Adresse prüfen, um festzustellen, ob die AVAX bereits eingetroffen sind:

curl -X POST --data '{
    "jsonrpc":"2.0",
    "id"     :7,
    "method" :"avm.getBalance",
    "params" :{
        "address":"X-avax1w4nt49gyv4e99ldqevy50l2kz55y9efghep0cs",
        "assetID"  :"AVAX"
    }
}' -H 'content-type:application/json;' 127.0.0.1:9650/ext/bc/X