Guide : Lancer votre node Denali avec AWS de A à Z

11 min readJun 1, 2020

Bonjour à tous, ce tutoriel à pour but de vous montrer pas à pas comment lancer une node sur le réseau Denali d’Avalabs, sous AWS. Par ailleurs, cela fonctionnera globalement de la même manière pour l’ensemble des fournisseurs de VPS.

1 — Amazon Web Service

Premièrement, il va bien tendu falloir se connecter ou créer un compte sur AWS si vous n’en avez pas. Cela est assez rapide.

Une fois connecté, vous voilà sur votre dashboard “AWS Management Console”. Vous pouvez dés à présent sélectionner la zone géographique où vous souhaitez créer votre VPS.

Pour créer votre VPS, vous allez cliquer sur l’onglet du menu en haut à gauche “Services->EC2”

Vous arrivez maintenant sur votre “EC2 Dashboard”. Il nous faut donc créer une instance, pour cela il faudra maintenant cliquer “Instances”

Cliquez sur “Lancer une instance”

Vous sélectionnez la version “Ubuntu Server 18.04 LTS (HVM), SSD Volume Type”

Les recommandations techniques pour une node sous Denali sont :

Minimum hardware requirements:

CPU: 2 GHz
RAM: 3 GB
Storage: 250 MB free space

Recommended hardware:

CPU: > 2 GHz
RAM: > 3 GB
Storage: > 5 GB free space on SSD

Vous allez donc sélectionner le type “t2.medium” pour avoir une configuration optimale. On clique ensuite sur “‘Vérifier et Lancer”

Voici les spécifications de notre instance :

2 vCPU
4 Gio de RAM
8 Go SSD

Vous pouvez cliquer sur “Launch”

Pour la connexion à distance, il est recommandé de créer une nouvelle “key pair”. Vous allez donc en créer une et la télécharger. Seulement ensuite, cliquez sur “lancer’

Votre instance est maintenant créée, la prochaine étape est la connexion à celle-ci. Pour cela je vous conseille de télécharger “Putty”, c’est un SSH et telnet client.

Cliquez sur l’id de votre instance pour accéder au dashboard des instances.

Une fois sur votre dashboard des instances, vous allez cliquer droit sur la ligne de notre instance → Connecter

Vous avez ensuite les informations sur comment vous connecter sur lien suivant : https://docs.aws.amazon.com/console/ec2/instances/connect/putty

2 — Bootstrap

Une fois votre Putty configurer pour se connecter en SSH à votre instance Amazon. Cela se présente comme ceci.

Votre login par défaut est : ubuntu

Vous devez mettre à jour notre version d’ubuntu.

sudo apt-get update

Vous allez maintenant installer Go.

wget https://dl.google.com/go/go1.13.linux-amd64.tar.gz

Utilisez tar pour extraire l’archive dans le répertoire /usr/local :

sudo tar -C /usr/local -xzf go1.13.linux-amd64.tar.gz

Pour que le système sache où trouver les binaries exécutables de Go, nous devons ajuster la variable d’environnement $PATH. Vous pouvez le faire en ajoutant la ligne suivante au fichier /etc/profile (pour une installation à l’échelle du système) ou au fichier $HOME/.profile (pour une installation de l’utilisateur actuel) :

export PATH=$PATH:/usr/local/go/bin

Enregistrez le fichier, et chargez la nouvelle variable d’environnement PATH dans la session shell actuelle :

source ~/.profile

Vérifiez l’installation en affichant la version Go

go version

Vous devriez avoir le résultat suivant

Vous pouvez maintenant installer notre Gecko.
Comme votre Ubuntu est une nouvelle installation, vous devez installer les bibliothèques suivantes :

sudo apt-get install libssl-dev libuv1-dev cmake make curl g++

Vous devez aussi installer git :

sudo apt install git

Cloner le répertoire Gecko :

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

Vous devriez voir un écran ressemblant à celui-ci, donnez-lui quelques minutes ou moins pour télécharger tous les fichiers nécessaires à partir du répertoire Gecko.

Il faut maintenant se positionner dans le bon répertoire

cd go/src/github.com/ava-labs/gecko

La commande ci-dessous va charger quelques fichiers, il lui faudra quelques minutes pour télécharger et compiler le fichier requis.

./scripts/build.sh

Si votre installation a été réussie, vous devriez avoir ce résultat.

Nous allons maintenant lancer la node et la connecter à AVA, afin que la node puisse tourner pendant toute la période nécessaire à l’incentive testnet. Nous allons utiliser la command “nohup”, celle-ci va garder notre node active, malgré le fait que nous quittions notre terminal putty à la fin de ce tutoriel.

nohup ./build/ava &

Vous devriez avoir un résultat comme celui-ci.

Pour verifier que le bootstrap se déroule bien, nous allons lire les logs de process ./build/ava avec la commande suivante :

tail -f nohup.out

Voici les logs du bootstrap de notre node :

Attendez quelques minutes afin que votre node se synchronise avec le réseau AVA. Faites Ctrl+C pour quitter les logs du bootstrap.

Afin de bien vérifier que le processus ./build/ava continu de tourner en arrière plan, nous allons exécuter la command suivante :

ps -ef

Vous devriez trouver ./build/ava dans la liste des processus en cours.

Pour la partie suivante le crédit revient à Avalabs et à Collin Cusce pour leur formidable travail

3 — Staker vos AVA

Etape 1 — Créer un utilisateur et des adresses

Pour devenir un validateur, un utilisateur doit être créé. L’appel API suivant permettra de créer un utilisateur avec le nom d’utilisateur et le mot de passe que vous spécifiez.

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

Maintenant que vous avez un compte, vous devez créer une adresse sur la X-chain. Cette adresse recevra l’AVA du faucet

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

Il en résultera une réponse comme suit, qui contient l’adresse que nous venons de créer. Vous devrez noter votre adresse X-Chain car nous l’utiliserons dans les étapes suivantes.

{
    "jsonrpc": "2.0",
    "result": {
        "address": "Votre adresse X-CHAIN"
    },
    "id": 1
}

Vous devez également créer un compte sur la P-Chain en utilisant votre utilisateur.

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

L’adresse de la P-chain est ainsi renvoyée. Vous devez également le noter, car vous l’utiliserez dans les étapes ultérieures.

{
    "jsonrpc": "2.0",
    "result": {
        "address": "Votre adresse P-CHAIN"
    },
    "id": 1
}

Etape 2 — Acquérir des fonds

Très bien ! Maintenant que vous avez des comptes, vous allez y mettre des fonds. Pour commencer, vous allez obtenir des fonds depuis le faucet AVA Testnet. Vous inscrivez votre adresse X-Chain dans le formulaire, vous confirmez que vous n’êtes pas un bot et vous demandez 20 000 nAVA (nano-AVA).

https://faucet.ava.network/

Ces fonds devraient arriver en moins de 2 secondes. Pour vérifier que les fonds se trouvent à votre adresse, appelez la fonction suivante, en remplaçant “VOTRE ADRESSE X-CHAINE ICI” par l’adresse X-Chain fournie par le faucet.

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

Vous recevrez la réponse suivante, confirmant que vous avez bien reçu vos AVA.

{
    "jsonrpc":"2.0",
    "id"     :2,
    "result" :{
        "balance":20000
    }
}

Etape 3 — Envoyez-les à la plate-forme

Vous avez les fonds ! Il est maintenant temps d’en faire quelque chose. Pour ce faire, Vous allez envoyer des AVA de votre compte X-Chain sur votre P-Chain. La P-Chain contrôle tous les comptes de participants et les jeux de données de validation. C’est là que la coordination de la plate-forme a lieu, et comme pour la X-Chain, elle est exécutée par défaut sur tous les nœuds de la plate-forme AVA.

L’appel API “exportAVA” lance une procédure sur le nœud local pour signer une transaction qui peut, en une seule étape, transférer des fonds de la X-Chain à la P-Chain au travers du réseau. Il s’agit d’un atomic-swap et chaque nœud le réalisera. Veillez à utiliser l’adresse de la P-Chain créée à l’étape 1, et non l’adresse de la X-Chain. Vous allez envoyer le montant minimum de mise Denali — 10 000 nAVA — à la P-Chain pour que vous puissiez valider sur le réseau.

curl -X POST --data '{
    "jsonrpc":"2.0",
    "id"     :1,
    "method" :"avm.exportAVA",
    "params" :{
        "username": "YOUR USERNAME",
        "password": "YOUR PASSWORD",
        "to":"Votre adresse P-CHAIN",
        "amount": 10000
    }
}' -H 'content-type:application/json;' 127.0.0.1:9650/ext/bc/X

Cela permettra de retourner une TxID dans la réponse. Vous n’avez pas besoin de conserver cette TxID et elle peut être ignorée.

L’étape suivante consiste à accepter ce transfert sur la P-Chain. Pour ce faire, vous devez transmettre votre adresse P-Chain à la fonction “importAVA” de la P-Chain, en indiquant que votre acceptez tous les AVA envoyés à cette adresse.

curl -X POST --data '{
    "jsonrpc": "2.0",
    "method": "platform.importAVA",
    "params": {
        "username": "Votre USERNAME",
        "password": "Votre PASSWORD",
        "to":"Votre adresse P-CHAIN",
        "payerNonce":1
    },
    "id": 1
}' -H 'content-type:application/json;' 127.0.0.1:9650/ext/bc/P

Il en résultera une chaîne de caractères représentant une transaction.

{
    "jsonrpc": "2.0",
    "result": {
        "tx": "1117xBwcr5fo1Ch4umyzjYgnuoFhSwBHdMCam2wRe8SxcJJvQRKSmufXM8aSqKaDmX4TjvzPaUbSn33TAQsbZDhzcHEGviuthncY5VQfUJogyMoFGXUtu3M8NbwNhrYtmSRkFdmN4w933janKvJYKNnsDMvMkmasxrFj8fQxE6Ej8eyU2Jqj2gnTxU2WD3NusFNKmPfgJs8DRCWgYyJVodnGvT43hovggVaWHHD8yYi9WJ64pLCvtCcEYkQeEeA5NE8eTxPtWJrwSMTciHHVdHMpxdVAY6Ptr2rMcYSacr8TZzw59XJfbQT4R6DCsHYQAPJAUfDNeX2JuiBk9xonfKmGcJcGXwdJZ3QrvHHHfHCeuxqS13AfU"
    },
    "id": 1
}

Vous prendrez la transaction qui en résultera et l’enverrez à la P-Chain à partir de l’appel API “issueTx”.

curl -X POST --data '{
    "jsonrpc": "2.0",
    "method": "platform.issueTx",
    "params": {
        "tx":"La TX ISSUE TRANSFERT ICI"
    },
    "id": 1
}' -H 'content-type:application/json;' 127.0.0.1:9650/ext/bc/P

Ce devrait être tout ! La P-Chain devrait disposer de fonds suffisants pour participer en tant que validateur au testnet Denali. Pour vérifier, vous appelez “getAccount” sur la P-Chain et vérifiez le solde.

curl -X POST --data '{
    "jsonrpc": "2.0",
    "method": "platform.getAccount",
    "params":{
        "address":"Votre adresse P-CHAIN"
    },
    "id": 1
}' -H 'content-type:application/json;' 127.0.0.1:9650/ext/bc/P

4 — Validation

Ça marche ! Maintenant que vous avez des fonds sur la P-Chain, votre êtes prêts à vous inscrire, afin de devenir un validateur sur le réseau. Chaque nœud a un “nodeID” qui est utilisé pour identifier de manière unique le nœud sur le réseau. Afin de devenir un validateur, vous devez enregistrer ce nodeID pour être le nœud qui fait le travail. La première chose à faire est de prendre votre nodeID et de le noter afin de pouvoir l’utiliser plus tard.

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

L’étape suivante consiste à créer une transaction qui ajoute votre nodeID au réseau. Dans l’exemple ci-dessous, vous fixez une heure de début à 15 minutes et vous terminez le 15 juin à 23h59 GMT.

curl -X POST --data '{
    "jsonrpc": "2.0",
    "method": "platform.addDefaultSubnetValidator",
    "params": {
        "id":"Votre nodeID",
        "payerNonce":2,
        "destination":"Votre adresse P-CHAIN",
        "startTime":'$(date --date="15 minutes" +%s)',
        "endTime":1592265599,
        "stakeAmount":10000
    },
    "id": 1
}' -H 'content-type:application/json;' 127.0.0.1:9650/ext/P

Cela retournera une transaction non signée qui ajoutera votre nœud à la liste des validateurs du réseau Denali.

{
    "jsonrpc":"2.0",
    "id"     :1,
    "result" :{
        "unsignedTx": "1115K3jV5Yxr145wi6kEYpN1nPz3GEBkzG8mpF2s2959VsR54YGenLJrgdg3UEE7vFPNDE5n3Cq9Vs71HEjUUoVSyrt9Z3X7M5sKLCX5WScTcQocxjnXfFowZxFe4uH8iJU7jnCZgeKK5bWsfnWy2b9PbCQMN2uNLvwyKRp4ZxcgRptkuXRMCKHfhbHVKBYmr5e2VbBBht19be57uFUP5yVdMxKnxecs"
    }
}

Vous allez copier cette transaction dans la fonction “signer”, qui renvoie une transaction signée.

curl -X POST --data '{
    "jsonrpc": "2.0",
    "method": "platform.sign",
    "params": {
        "username": "YOUR USERNAME HERE",
        "password": "YOUR PASSWORD HERE",
        "tx":"THE VALIDATION UNSIGNED TX HERE",
        "signer":"Votre adresse P-CHAIN"
    },
    "id": 2
}' -H 'content-type:application/json;' 127.0.0.1:9650/ext/P

La réponse devrait ressembler à ceci :

{
    "jsonrpc": "2.0",
    "result": {
        "Tx": "111Bit5JNASbJyTLrd2kWkYRoc96swEWoWdmEhuGAFK3rCAyTnTzomuFwgx1SCUdUE71KbtXPnqj93KGr3CeftpPN37kVyqBaAQ5xaDjr7wVBTUYi9iV7kYJnHF61yovViJF74mJJy7WWQKeRMDRTiPuii5gsd11gtNahCCsKbm9seJtk2h1wAPZn9M1eL84CGVPnLUiLP"
    },
    "id": 1
}

Ensuite, vous prenez cette transaction signée et l’émettons à la P-Chain afin de devenir un validateur dans le réseau Denali.

curl -X POST --data '{
    "jsonrpc": "2.0",
    "method": "platform.issueTx",
    "params": {
        "tx":"Votre Tx VALIDATION Signée ici "
    },
    "id": 3
}' -H 'content-type:application/json;' 127.0.0.1:9650/ext/P

Et ce devrait être le cas ! Vous devriez vous voir dans la liste des validateurs en attente maintenant, et dans 15 minutes nous serons dans la liste des validateurs actifs !

curl -X POST --data '{
    "jsonrpc": "2.0",
    "method": "platform.getPendingValidators",
    "params": {},
    "id": 4
}' -H 'content-type:application/json;' 127.0.0.1:9650/ext/Pcurl -X POST --data '{
    "jsonrpc": "2.0",
    "method": "platform.getCurrentValidators",
    "params": {},
    "id": 1
}' -H 'content-type:application/json;' 127.0.0.1:9650/ext/P

Vous pouvez aussi vérifier directement sur l’explorer AVA que votre node apparaît bien dans la liste des nodes en attentes ou actives : https://explorer.ava.network/validators

Vous voulez aussi savoir depuis combien d’heures votre nœud fonctionne ?

Utiliser la commande suivante :

ps -eo etime,args | grep ava

Vous devriez avoir ce résultat:

Redémarrer votrer node

Exécutez la commande suivante :

curl -s  https://raw.githubusercontent.com/ablockio/Auto-AVA-Denali-node-deployment/master/reboot_node.sh | bash

Vous devriez avoir le résultat suivant

Votre node à bien été redémarrée

Mettre à jour votre node

Pour mettre à jour votre node dans la dernière version, exécutez la commande suivante :

curl -s https://raw.githubusercontent.com/ablockio/Auto-AVA-Denali-node-deployment/master/reboot_node_update.sh | bas

Issue #1:

Si vous essayez d’exporter la clé privée de votre portefeuille P-Chain et que vous obtenez ce résultat :

Suivez les étapes suivantes :

systemctl status avanode

Si vous avez obtenu le résultat suivant :

Tapez :

ps -ef

Vous allez tuer le processus ./build/ava et redémarrer votre nœud.

Pour tuer le processus ava, exécutez la commande suivante, (Votre ./build/ava PID sera différent) :

kill -9 1914

et redémarrer :

curl -s  https://raw.githubusercontent.com/ablockio/Auto-AVA-Denali-node-deployment/master/reboot_node.sh | bash

Vous pouvez maintenant réessayer, et obtenir votre clé privée de portefeuille P-chain.

ablock lien :

ablock est un service professionnel de validateur communautaire.

Website : https://ablock.io

Telegram Group: https://t.me/ablockio

Twitter : https://twitter.com/ablock_io

A propos d’AVA Labs:

AVA est une plateforme open-source pour le lancement d’applications hautement décentralisées, de services financiers et de nouvelles blockchains interpolables.