Avalanche Francophone
  • Documentation du développeur
  • Apprendre
    • Aperçu de la plateforme
      • Staking
      • Frais de transaction
    • Les bases de la blockchain
    • FAQ
    • Forum
    • Communauté
  • Créer
  • Pour commencer: exécuter un nœud Avalanche
  • Notes de version
    • Alertes par email
    • Notes de mise à jour d'AvalancheGo
    • Notes de mise à jour d'Ortelius
  • Tutoriels
    • Plateforme
      • Créer une nouvelle blockchain
      • Créer un Réseau Local Testnet
      • Créer un sous-réseau (subnet)
      • Créer une Machine Virtuelle (VM)
      • Configurez votre Ledger Nano S avec Avalanche
      • Transférer de l'AVAX entre la X-Chain et la C-Chain
      • Transférer de l'AVAX entre la X-Chain et la P-Chain
    • Nœuds et mise en jeu
      • Ajouter un validateur
      • Maintenir un nœud Avalanche
      • Exécutez un nœud Avalanche et devenez validateur
      • Exécuter un nœud Avalanche avec Oracle VM VirtualBox
      • Exécutez un nœud Avalanche avec un Raspberry Pi 4
      • Exécutez un nœud Avalanche et faites une mise en jeu avec le portefeuille
      • Exécuter un nœud Avalanche avec OVH
      • Exécuter un nœud Avalanche avec Amazon Web Services (AWS)
      • Exécuter un nœud Avalanche avec Microsoft Azure
      • Exécuter un nœud Avalanche sous Linux à l'aide du script d'installation
      • Configuration du monitoring des nœuds
      • Mise en jeu d'AVAX, en validant ou délégant via le portefeuille Avalanche
      • Déléguer à un nœud
      • Sécurisation d'un serveur VPS
      • Mettez à niveau votre nœud AvalancheGo
    • Contrats intelligents
      • Déployer un contrat intelligent en utilisant Remix et MetaMask
      • Utilisation de Truffle avec la C-Chain d'Avalanche
    • Actifs Numériques Intelligents
      • Créer un token ERC-20
      • Créer un actif à capitalisation fixe
      • Créer un actif à capitalisation variable
      • Création d'un NFT - Partie 1
      • Créez des NFT avec le portefeuille Avalanche
      • Utilisez les Wrapped AVAX (WAVAX) sur Avalanche
  • AvalancheGo APIs
    • Émettre des appels d'API
    • Platform API (P-Chain)
    • EVM API (C-Chain)
    • AVM API (X-Chain)
    • Appels d'API obsolètes
    • API Admin
    • API Auth
    • API Health
    • API Info
    • API IPC
    • API Keystore
    • API Metrics
    • API Timestamp
  • Outils
    • AvalancheJS
      • Créer un actif sur la X-Chain
      • Management des clés sur la X-Chain
      • Envoyer un actif sur la X-Chain
      • API
    • Avash
    • Ortelius
  • Références
    • AVM Transaction Format
    • Command Line Interface
    • Coreth Atomic Transaction Format
    • Cryptographic Primitives
    • Network Protocol
    • Serialization Primitives
    • Platform Transaction Format
  • Papiers
Propulsé par GitBook
Sur cette page
  • Introduction
  • Mise en garde : Sécurité
  • Contributions
  • Configurer Prometheus
  • Installez Grafana
  • Configurer node_exporter
  • Configurer les tâches AvalancheGo et node_exporter Prometheus

Cet article vous a-t-il été utile ?

  1. Tutoriels
  2. Nœuds et mise en jeu

Configuration du monitoring des nœuds

Configuration d'une infrastructure pour surveiller les performances de votre nœud.

PrécédentExécuter un nœud Avalanche sous Linux à l'aide du script d'installationSuivantMise en jeu d'AVAX, en validant ou délégant via le portefeuille Avalanche

Dernière mise à jour il y a 4 ans

Cet article vous a-t-il été utile ?

Introduction

Ce tutoriel suppose que vous avez Ubuntu 18.04 ou 20.04 en cours d'exécution sur votre nœud. Une version Mac OS X de ce tutoriel viendra plus tard.

Ce tutoriel montrera comment configurer une infrastructure pour surveiller une instance d'. Nous utiliserons :

  • pour collecter et stocker des données.

  • pour obtenir des informations sur la machine.

  • AvalancheGo metrics API pour obtenir des informations sur le nœud.

  • pour visualiser les données sur un tableau de bord.

Conditions préalables :

  • Un nœud AvalancheGo en cours d'exécution.

  • Shell access à la mahcine exécutant le nœud.

  • Privilèges d'administrateur sur la machine.

Mise en garde : Sécurité

Le système décrit ici ne doit pas être ouvert à l'Internet public. Ni Prometheus ni Grafana, comme illustré ici, ne sont protégés contre les accès non autorisés. Assurez-vous que les deux ne sont accessibles que via un proxy sécurisé, un réseau local ou un VPN. Cette configuration dépasse le cadre de ce didacticiel, mais soyez prudent. De mauvaises pratiques de sécurité pourraient amener les attaquants à prendre le contrôle de votre nœud! Il est de votre responsabilité de suivre les bonnes pratiques de sécurité.

Contributions

La base du tableau de bord Grafana a été tirée des gars de , qui n'est apparemment plus disponible. Si vous avez des idées et des suggestions pour améliorer ce didacticiel, veuillez le dire, publier un problème ou faire une pull request sur .

Configurer Prometheus

Nous devons d'abord ajouter un compte d'utilisateur système et créer des répertoires (vous aurez besoin des informations d'identification du superutilisateur) :

sudo useradd -M -r -s /bin/false prometheus
sudo mkdir /etc/prometheus /var/lib/prometheus
mkdir -p /tmp/prometheus && cd /tmp/prometheus
wget https://github.com/prometheus/prometheus/releases/download/v2.21.0/prometheus-2.21.0.linux-amd64.tar.gz
tar xvf prometheus-2.21.0.linux-amd64.tar.gz
cd prometheus-2.21.0.linux-amd64

Ensuite, nous devons déplacer les binaires, définir la propriété et déplacer les fichiers de configuration vers les emplacements appropriés :

sudo cp {prometheus,promtool} /usr/local/bin/
sudo chown prometheus:prometheus /usr/local/bin/{prometheus,promtool}
sudo chown -R prometheus:prometheus /etc/prometheus
sudo chown prometheus:prometheus /var/lib/prometheus
sudo cp -r {consoles,console_libraries} /etc/prometheus/
sudo cp prometheus.yml /etc/prometheus/

/etc/prometheus est utilisé pour la configuration et /var/lib/prometheus pour les données.

Configurons Prometheus pour qu'il s'exécute en tant que service système. Faites :

sudo nano /etc/systemd/system/prometheus.service

Et entrez la configuration suivante :

[Unit]
Description=Prometheus
Documentation=https://prometheus.io/docs/introduction/overview/
Wants=network-online.target
After=network-online.target

[Service]
Type=simple
User=prometheus
Group=prometheus
ExecReload=/bin/kill -HUP $MAINPID
ExecStart=/usr/local/bin/prometheus   --config.file=/etc/prometheus/prometheus.yml   --storage.tsdb.path=/var/lib/prometheus   --web.console.templates=/
etc/prometheus/consoles   --web.console.libraries=/etc/prometheus/console_libraries   --web.listen-address=0.0.0.0:9090   --web.external-url=

SyslogIdentifier=prometheus
Restart=always

[Install]
WantedBy=multi-user.target

Enregistrez le fichier. Nous pouvons maintenant exécuter Prometheus en tant que service système :

sudo systemctl daemon-reload
sudo systemctl start prometheus
sudo systemctl enable prometheus

Prometheus devrait maintenant fonctionner. Pour nous en assurer, nous pouvons vérifier avec :

systemctl status prometheus 

Ce qui devrait produire quelque chose comme :

● prometheus.service - Prometheus
     Loaded: loaded (/etc/systemd/system/prometheus.service; enabled; vendor preset: enabled)
     Active: active (running) since Wed 2020-04-01 19:23:53 CEST; 5 months 12 days ago
       Docs: https://prometheus.io/docs/introduction/overview/
   Main PID: 1767 (prometheus)
      Tasks: 12 (limit: 9255)
     CGroup: /system.slice/prometheus.service
             └─1767 /usr/local/bin/prometheus --config.file=/etc/prometheus/prometheus.yml --storage.tsdb.path=/var/lib/prometheus --web.console.templa>

Sep 13 13:00:04 ubuntu prometheus[1767]: level=info ts=2020-09-13T11:00:04.744Z caller=head.go:792 component=tsdb msg="Head GC completed" duration=13.6>
Sep 13 13:00:05 ubuntu prometheus[1767]: level=info ts=2020-09-13T11:00:05.263Z caller=head.go:869 component=tsdb msg="WAL checkpoint complete" first=9>
Sep 13 15:00:04 ubuntu prometheus[1767]: level=info ts=2020-09-13T13:00:04.776Z caller=compact.go:495 component=tsdb msg="write block" mint=15999912000>
...

Vous pouvez également vérifier l'interface Web de Prometheus, disponible sur http://your-node-host-ip:9090/

Vous devrez peut-être faire sudo ufw allow 9090/tcp si le pare-feu est activé).

Installez Grafana

Pour configurer les référentiels de Grafana avec Ubuntu :

sudo apt-get install -y apt-transport-https
sudo apt-get install -y software-properties-common wget
wget -q -O - https://packages.grafana.com/gpg.key | sudo apt-key add -
echo "deb https://packages.grafana.com/oss/deb stable main" | sudo tee -a /etc/apt/sources.list.d/grafana.list

Pour installer Grafana :

sudo apt-get update
sudo apt-get install grafana

Pour le configurer en tant que service :

sudo systemctl daemon-reload
sudo systemctl start grafana-server
sudo systemctl enable grafana-server.service

Pour vous assurer qu'il fonctionne correctement :

sudo systemctl status grafana-server

Cela devrait monter Grafan comme actif. Grafana devrait maintenant être disponible sur http://your-node-host-ip:3000/Connectez-vous avec le nom d'utilisateur / mot de passe admin / admin et configurez un nouveau mot de passe sécurisé. ** Nous devons maintenant connecter Grafana à notre source de données, Prometheus.

Vous devrez peut-être faire sudo ufw allow 3000/tcp si le pare-feu est activé.

Sur l'interface Web de Grafana :

  • Accédez à Configuration dans le menu de gauche et sélectionnez "Data Sources".

  • Cliquez sur "Add Data Source".

  • Sélectionnez Prometheus.

  • Dans le formulaire, entrez le nom (Prometheus fera l'affaire) et http://localhost:9090 comme URL.

  • Cliquez sur Save & Test

  • Vérifiez que le message vert suivant apparait "Data source is working".

Configurer node_exporter

En plus des métriques d'AvalancheGo, mettons en place la surveillance de la machine elle-même, afin que nous puissions vérifier l'utilisation du processeur, de la mémoire, du réseau et du disque et être au courant de toute anomalie. Pour cela, nous utiliserons node_exporter, un plugin Prometheus.

Obtenez la dernière version avec:

curl -s https://api.github.com/repos/prometheus/node_exporter/releases/latest | grep browser_download_url | grep linux-amd64 |  cut -d '"' -f 4 | wget -qi -

Changez linux-amd64 si vous avez une architecture différente (RaspberryPi est linux-arm64, par exemple).

Décompressez et déplacez l'exécutable :

tar xvf node_exporter-1.0.1.linux-amd64.tar.gz
sudo mv node_exporter-1.0.1.linux-amd64/node_exporter /usr/local/bin
node_exporter --version

Ensuite, nous ajoutons node_exporter en tant que service. Faites :

sudo nano /etc/systemd/system/node_exporter.service

Et remplissez le formulaire avec :

[Unit]
Description=Prometheus
Documentation=https://github.com/prometheus/node_exporter
Wants=network-online.target
After=network-online.target

[Service]
Type=simple
User=prometheus
Group=prometheus
ExecReload=/bin/kill -HUP $MAINPID
ExecStart=/usr/local/bin/node_exporter \
    --collector.cpu \
    --collector.diskstats \
    --collector.filesystem \
    --collector.loadavg \
    --collector.meminfo \
    --collector.filefd \
    --collector.netdev \
    --collector.stat \
    --collector.netstat \
    --collector.systemd \
    --collector.uname \
    --collector.vmstat \
    --collector.time \
    --collector.mdadm \
    --collector.zfs \
    --collector.tcpstat \
    --collector.bonding \
    --collector.hwmon \
    --collector.arp \
    --web.listen-address=:9100 \
    --web.telemetry-path="/metrics"

[Install]
WantedBy=multi-user.target

Cela configure node_exporter pour collecter diverses données que nous pourrions trouver intéressantes. Démarrez le service et activez-le au démarrage :

sudo systemctl start node_exporter
sudo systemctl enable node_exporter
sudo systemctl status node_exporter

Nous sommes maintenant prêts à tout lier ensemble.

Configurer les tâches AvalancheGo et node_exporter Prometheus

Assurez-vous que votre nœud AvalancheGo fonctionne avec les arguments de ligne de commande appropriés. L'API de métriques doit être activée (par défaut, c'est le cas). Si vous utilisez l'argument CLI --http-host pour effectuer des appels d'API depuis l'extérieur de la machine hôte, notez l'adresse à laquelle les API écoutent.

Nous devons maintenant définir un emploi Prometheus approprié. Modifions la configuration de Prometheus:

Faites :

sudo nano /etc/prometheus/prometheus.yml

Et ajouter :

  - job_name: 'avalanchego'
    metrics_path: '/ext/metrics'
    static_configs:
      - targets: ['<your-host-ip>:9650']

  - job_name: 'avalanchego-machine'
    static_configs:
      - targets: ['<your-host-ip>:9100']
        labels:
          alias: 'machine'

L'indentation est importante. Assurez-vous que -job_name est aligné sur l'entrée existante -job_name et que les autres lignes sont également correctement mises en retrait. Assurez-vous d'utiliser la bonne adresse IP d'hôte, ou localhost, en fonction de la configuration de votre nœud.

Enregistrez le fichier de configuration et redémarrez Prometheus :

sudo systemctl restart prometheus

Vérifiez l'interface Web de Prometheus sur http://your-node-host-ip:9090/targets. Vous devriez voir trois cibles activées :

  • Prometheus

  • Avalanchego

  • Avalanchego-machine

Pour importer le tableau de bord préconfiguré :

  • Ouvrez l'interface Web de Grafana.

  • Cliquez sur + dans la barre d'outils de gauche.

  • Sélectionnez Import JSON, puis téléchargez le fichier JSON.

C'est tout ! Vous pouvez maintenant vous émerveiller de tout ce que fait votre nœud. Woohoo!

Ensuite, obtenez le lien vers la dernière version de Prometheus sur la (assurez-vous de sélectionner l'architecture de processeur appropriée) et utilisez wget pour le télécharger, et tar pour décompresser l'archive :

Ouvrez Grafana; vous pouvez maintenant créer un tableau de bord en utilisant l'une de ces sources. Vous pouvez également utiliser les tableaux de bord préconfigurés .

AvalancheGo
Prometheus
Node_exporter
Grafana
ColmenaLabs
Github
page de téléchargement
[ici]