Das Cudos Network ist eine spezielle Blockchain, die entwickelt wurde, um leistungsstarkes, vertrauensloses und erlaubnisfreies Cloud-Computing für alle bereitzustellen.

Sie möchten mit der Validierung für CUDOSbeginnen? Dann sind Sie bei uns genau richtig! Im Folgenden finden Sie eine detaillierte Schritt-für-Schritt-Anleitung, wie Sie Ihren eigenen Validator in CUDOS einrichten.

An dieser Stelle werden wir von der offiziellen Dokumentation abweichen und uns für CentOS entscheiden.

Die Einrichtung der Umgebung soll auf allen Hostcomputern erfolgen. Hardware-Voraussetzungen finden Sie
hier
. Sobald Sie einen Host-Computer hochgefahren haben, führen Sie die folgenden Schritte aus.

Wenn Sie gerade erst mit diesem Tutorial begonnen haben, beginnen Sie mit dem Hochfahren eines Validierungscomputers.

Zuerst müssen wir ein paar Tools installieren.

# Install Docker, Git and jQuery via the yum package manager.
$ sudo yum install docker git jq -y# Start the Docker daemon.
$ sudo service docker start# Install docker-compose by downloading the binary from the GitHub download archive.
$ curl -L "https://github.com/docker/compose/releases/download/1.29.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose# Make docker-compose executable for the current user.
$ chmod +x /usr/local/bin/docker-compose

Lassen Sie uns nun einen Arbeitsbereich im Verzeichnis $HOME und cd darin erstellen.

$ mkdir ~/cudos
$ cd ~/cudos

Next, müssen wir CudosNode, CudosBuilders und CudosGravityBridge klonen.

$ git clone --depth 1 --branch v0.2 https://github.com/CudoVentures/cudos-node.git CudosNode
$ git clone --depth 1 --branch v0.3  https://github.com/CudoVentures/cudos-builders.git CudosBuilders
$ git clone --depth 1 --branch v0.2 https://github.com/CudoVentures/cosmos-gravity-bridge.git CudosGravityBridge

Erstellen Sie das Docker-Image für CudosBuilders.

$ cd ~/cudos/docker/binary-builder
$ sudo docker-compose --env-file binary-builder.arg -f binary-builder.yml -p cudos-binary-builder up --build --detach

Okay, es ist Zeit, sich auf das Wesentliche einzulassen. Das Validator-Setup umfasst die Einrichtung von drei Komponenten:

  • Der CUDOS-Validator, der am On-Chain-Konsens teilnimmt, indem er über Blöcke abstimmt und diese vorschlägt, und der vom Orchestrator verwendet wird, um seinen Aufruf gegen die CUDOS-Kette zu machen
  • Der Gravity Bridge Orchestrator,der den Token-Fluss zwischen CUDOS und Ethereum verwaltet
  • Ein Ethereum Full Node,der vom Orchestrator verwendet wird, um seine Aufrufe gegen Ethereum zu tätigen

1.1) Ethereum Full Node Einrichtung

Starten Sie zunächst eine neue Host-Maschine (siehe Hardwareanforderungen für „Ethereum-Knoten“).

Alternativ können Sie auch Ihren eigenen Ethereum-Vollknoten verwenden, in diesem Fall können Sie zu 1.2 springen). Stellen Sie nur sicher, dass Sie Infura nicht verwenden.

Erinnerung:Schließen Sie die „0) Umgebungseinrichtung“ ab, bevor Sie mit den folgenden Schritten fortfahren.

Das Ausführen eines Ethereum-Knotens ist ziemlich einfach.

$ cd ~/cudos/CudosBuilders/docker/ethereum
$ sudo docker-compose -f ethereum-full.yml -p ethereum up --build --detach

Beachten Sie, dass die Synchronisierung der Rinkeby-Blockchain Stunden / Tage dauern kann. Sie können die Protokolle anzeigen, indem Sie den folgenden Befehl ausführen.

$ sudo docker logs -f ethereum

1.2) CUDOS Validator Node Einrichtung

Starten Sie zunächst einen neuen Hostcomputer (siehe Hardwareanforderungen für den „Validator-Knoten“). Wir werden einen CUDOS-Vollknoten initialisieren, den wir später als Validator konfigurieren werden.

Erinnerung:Schließen Sie die „0) Umgebungseinrichtung“ ab, bevor Sie mit den folgenden Schritten fortfahren.

# Navigate to the full-node directory of CudosBuilders.
$ cd ~/cudos/CudosBuilders/docker/full-node# Make a copy of the example full-node env file and open it with a text editor of your choice.
$ cp full-node.env.example full-node.client.testnet.public01.env
$ nano full-node.client.testnet.public01.env# Add the following contents to the file. Once you're done, save the changes and close the file.
MONIKER=<Insert your validator moniker here>
SHOULD_USER_GLOBAL_PEERS=false# Initialize the full node.
$ sudo docker-compose --env-file full-node.client.testnet.public01.arg -f init-full-node.yml -p cudos-init-full-node-client-testnet-public-01 up --build

Wenn alles gut gelaufen ist, sollte es ein ~/cudos/CudosData Verzeichnis geben.

$ ls ~/cudos
CudosBuilders  CudosData  CudosGravityBridge  CudosNode
                   /\
                   ||
     This directory should be there.

Lassen Sie uns auch sicherstellen, dass alle Dateien ordnungsgemäß generiert wurden.

$ ls ~/cudos/CudosData/cudos-data-full-node-client-testnet-public-01
config  data  tendermint.nodeid

Kopieren Sie die Knoten-ID und fügen Sie sie in eine Textdatei auf Ihrem lokalen Computer ein. Sie werden es in Kürze brauchen.

$ cat ~/cudos/CudosData/cudos-data-full-node-client-testnet-public-01/tendermint.nodeid

Sieht bisher gut aus. Um Peers zu erhalten, empfiehlt es sich nun, einen Sentry-Knoten auf einem anderen Hostcomputer hochzufahren.

  • Wiederholen Sie den Schritt „0) Environment Setup“ auf dem Sentry-Knoten.
  • Befolgen Sie die offizielle Sentry-Einrichtungsanleitung.
    Für Schritt 6 benötigen Sie die Knoten-ID des Validators aus der oben genannten Textdatei und die öffentliche IP-Adresse des Validators. Stellen Sie sicher, dass Port 26656 für eingehende und ausgehende Verbindungen geöffnet ist. Im Moment müssen Sie keine anderen Peer-Adressen als die Ihres Validators eingeben.
  • Rufen Sie die Knoten-ID des Sentrys ab, kopieren Sie sie und fügen Sie sie in eine Textdatei auf Ihrem lokalen Computer ein. Sie werden es in Kürze brauchen.
$ cat ~/cudos/CudosData/cudos-data-sentry-node-client-testnet-public-01/tendermint.nodeid
  • Im Idealfall sollten Sie mindestens zwei Sentry-Knoten für einen effektiven DDoS-Schutz einrichten. Wiederholen Sie einfach die drei obigen Schritte auf einem anderen Hostcomputer.

Optional: Richten Sie einen Seed-Knoten ein. Wir überspringen diesen Schritt in diesem Handbuch jedoch.

Nachdem wir unsere Sentries eingerichtet haben, müssen wir sie als Peers zu unserem Validator-Knoten hinzufügen.

$ cd ~/cudos/CudosBuilders/docker/full-node
$ nano full-node.client.testnet.public01.env# Add the following contents to the file. Once you're done, save the changes and close the file.
PERSISTENT_PEERS=<sentry1-node-id>@<sentry1-public.ip>:26656,<sentry2-node-id>@<sentry2-public.ip>:26656

In Ordnung, es ist Zeit, den vollständigen Knoten zu starten.

# Set the configuration.
$ sudo docker-compose --env-file full-node.client.testnet.public01.arg -f config-full-node.yml -p cudos-config-full-node-client-testnet-public-01 up --build# Start the full node.
sudo docker-compose --env-file full-node.client.testnet.public01.arg -f start-full-node.yml -p cudos-start-full-node-client-testnet-public-01 up --build --detach# Logs can be viewed by running the following command.
$ sudo docker logs -f cudos-start-full-node-client-testnet-public-01

An diesem Punkt, da wir den vollständigen Knoten erst vor ein paar Augenblicken gestartet haben, wird er immer noch die Blockchain synchronisieren. Abhängig von Ihrer Hardware und der Größe der Blockchain kann dies Stunden / Tage dauern. Sie können den Synchronisierungsstatus mit den folgenden Befehlen überprüfen.

# Wait for the output of this command to be 'false'.
$ sudo docker exec -ti cudos-start-full-node-client-testnet-public-01 cudos-noded status | jq '.SyncInfo.catching_up'# Check the progress by comparing the block height from the output of this command with the latest block height from the official block explorer.
$ sudo docker exec -ti cudos-start-full-node-client-testnet-public-01 cudos-noded status | jq '.SyncInfo.latest_block_height'

In der Zwischenzeit können wir ein Konto erstellen, das für die Interaktion mit der Blockchain benötigt wird. Wir werden eine mit der Weberweiterung Keplr erstellen. Bitte folgen Sie dieser Anleitung.

Vergessen Sie nicht, die mnemonische Phrase zu sichern und an einem sicheren Ort aufzubewahren!

Sobald der Knoten aufgeholt hat, können wir unser Validierungskonto importieren, das wir gerade in Keplr erstellt haben. Dazu müssen wir auf die Container-Shell des Validators zugreifen.

$ sudo docker exec -it cudos-start-full-node-client-testnet-public-01 bash

Führen Sie dann den folgenden Befehl aus, in dem Sie aufgefordert werden, die mnemonische Phrase einzugeben.

$ cudos-noded keys add validator --recover --keyring-backend file

Um zu überprüfen, ob der Schlüssel erfolgreich hinzugefügt wurde, verwenden Sie den folgenden Befehl, der einen „Validator“ -Schlüssel auflisten sollte.

$ cudos-noded keys list --keyring-backend file

Bevor wir unseren Validator on-chain erstellen können, braucht es einige Token, die es selbst einsetzen kann, so dass es tatsächlich ein Validator werden und am Konsens teilnehmen kann.

  • Befolgen Sie für das öffentliche Testnet diese Anweisungen.
  • Für das Mainnet finden Sie hier eine Liste von Orten, an denen Sie CUDOS kaufen können.

Sobald Sie einige Token haben, können wir jetzt den Validator on-chain mit dem folgenden Befehl erstellen.

$ cudos-noded tx staking create-validator \
  --amount <STAKE> \
  --from validator \
  --pubkey $(cudos-noded tendermint show-validator) \
  --moniker <YOUR_MONIKER> \
  --chain-id <CHAIN_ID> \
  --commission-rate <COM_RATE> \
  --commission-max-rate <COM_MAX_RATE> \
  --commission-max-change-rate <COM_MAX_CHANGE_RATE> \
  --min-self-delegation 1 \
  --gas auto \
  --gas-prices 0.025acudos \
  --gas-adjustment 1.80 \
  --keyring-backend file \
  -y
  • <STAKE > muss mindestens 1000000000000000000000000Acudos (=1 CUDOS) betragen
  • <YOUR_MONIKER > muss derselbe Moniker sein, den Sie unter ~/cudos/CudosBuilders/docker/full-node/full-node.client.testnet.public01.env angegeben haben.
  • <CHAIN_ID sollte > cudos-testnet-public für Testnet (TBD für Mainnet) sein
  • <COM_RATE ist > der Prozentsatz der Provision, den Sie von allen Belohnungen nehmen möchten, d.h. 0,10 bedeutet, dass Sie 10% aller generierten Belohnungen erhalten
  • <COM_MAX_RATE ist > der maximale Provisionssatz, zu dem Sie sich verpflichten, d.h. 0,40 bedeutet, dass Sie nie mehr als 40% aller generierten Belohnungen erhalten werden
  • <COM_MAX_CHANGE_RATE ist > der maximale Satz in Prozent, dass Sie Ihren Provisionssatz pro Tag ändern können, d.h. 0,20 bedeutet, dass Sie pro Tag Ihre Provision entweder erhöhen oder verringern können 20% Tops

Führen Sie den Befehl aus, und warten Sie, bis er verarbeitet wurde. Wenn Sie einen Transaktionshash sehen, ohne einen Fehler zu erhalten, haben Sie erfolgreich ein Validierungskonto erstellt! Sie können den Transaktionshash kopieren und im Block-Explorerbetrachten.

Außerdem sollten Sie in der Lage sein, Ihren Validator in der Liste zu finden, die mit dem folgenden Befehl ausgedruckt wird (suchen Sie nach Ihrem Spitznamen).

$ cudos-noded q staking validators

Bitte beenden Sie die Container-Shell-Sitzung nicht, da wir im nächsten Schritt weiter am Validator arbeiten werden.

1.3) Orchestrator-Setup

Für den Orchestrator benötigen wir ein anderes Konto auf dem Validierungscomputer. Erstellen Sie eine in Keplr, sichern Sie die mnemonische Phrase und bewahren Sie sie an einem sicheren Ort auf. Verwenden Sie dann den folgenden Befehl, um das Orchestratorkonto zu importieren, in dem Sie aufgefordert werden, den mnemonischen Ausdruck des Orchestratorkontos einzugeben.

$ cudos-noded keys add orchestrator --recover --keyring-backend file

Um zu überprüfen, ob der Schlüssel erfolgreich hinzugefügt wurde, verwenden Sie den folgenden Befehl, der einen „Validator“ -Schlüssel und den neu hinzugefügten „Orchestrator“ -Schlüssel auflisten sollte.

$ cudos-noded keys list --keyring-backend file

Für die nächsten Schritte benötigen Sie ein Ethereum-Konto. Bitte befolgen Sie diese Anleitung zum Installieren und Einrichten von Metamask und erstellen Sie ein Konto. Sobald Sie eine Ethereum-Adresse haben, können wir den Orchestrator registrieren.

$ cudos-noded tx gravity set-orchestrator-address <VALIDATOR_ADDRESS> <ORCH_ADDRESS> <ETH_ADDRESS>
  • <VALIDATOR_ADDRESS ist > die Operatoradresse des Validators (cudosvaloper…). Es kann mit dem folgenden Befehl abgerufen werden.
$ cudos-noded keys show validator --bech val --keyring-backend file
  • <ORCH_ADDRESS ist > die Adresse des Orchestrators (cudos…). Es kann mit dem folgenden Befehl abgerufen werden.
$ cudos-noded keys show orchestrator --keyring-backend file
  • <ETH_ADDRESS > ist die Ethereum-Adresse, die Sie in Metamask erstellt haben (0x…).

Nachdem Sie den Orchestrator registriert haben, müssen wir ihn konfigurieren.

$ cd ~/cudos/CudosBuilders/docker/orchestrator
$ cp orchestrator.env.example orchestrator.client.testnet.public01.env
$ nano orchestrator.client.testnet.public01.env# Add the following contents to the file. Once you're done, save the changes and close the file.
ADDRESS_PREFIX="cudos"
FEES="<FEES>"
GRPC="http://<CUDOS_NODE_IP>:9090"
ETHRPC="http://<ETH_NODE_IP>:8545"
CONTRACT_ADDR="0xb22F2A4c231e69703FC524Eb2E3eb7B83C316F42"
COSMOS_ORCH_MNEMONIC="<ORCH_MNEMONIC>"
ETH_PRIV_KEY_HEX="<HEX_PRIV_KEY>"
  • <GEBÜHREN > sind die Gebühren, die Sie für jede Brückentransaktion zahlen müssen, z. B. 100 Akudos.
  • <CUDOS_NODE_IP ist > die öffentliche IP-Adresse des CUDOS-Validator-Knotens.
  • <ETH_NODE_IP ist > die öffentliche IP-Adresse des Ethereum-Vollknotens.
  • <ORCH_MNEMONIC ist > die mnemonische Phrase Ihres Orchestrator-Kontos.
  • <ETH_PRIV_KEY_HEX ist > die hexadezimale Darstellung, wenn der private Schlüssel des Ethereum-Kontos ist, ohne das führende „0x“. Bitte folgen Sie dieser Anleitung, um den privaten Schlüssel aus Metamask zu exportieren.

Führen Sie schließlich den Orchestrator aus.

$ sudo docker-compose --env-file orchestrator.client.testnet.public01.arg -f orchestrator.release.yml -p cudos-orchestrator-client-testnet-public-01-release up --build --detach

Sie können die Protokolle mit dem folgenden Befehl anzeigen.

$ sudo docker logs -f cudos-orchestrator-client-testnet-public-01-release

Und das schließt es ziemlich ein! Sie betreiben jetzt einen Validator-Knoten auf der CUDOS-Blockchain und einen Orchestrator zur Überbrückung von Token-Transfers zwischen Cosmos und Ethereum!

Wir hoffen, Sie fanden diesen Leitfaden hilfreich und verlassen uns mit einem Klatschen!

Bis zum nächsten Mal!

Weitere Informationen:

Website, Twitter, Telegramm, YouTube, Discord, Medium, Podcast