grzegorznowak.cardano_node

Rôle de Noeud Cardano

Installe le Noeud Cardano en tant que service systemd sur Ubuntu et Debian. Ensuite, il l’encapsule avec Ansible pour rendre certaines opérations contrôlables, idempotentes et bien plus simples en général.

Peut ajouter et intégrer CNCLI sur demande.

Distros Supportées

L'adoption et le support de plus de distributions dépendra fortement des retours des utilisateurs.

Veuillez ajouter vos cas d'utilisation dans le système de suivi des problèmes et nous les traiterons au fur et à mesure.

Ubuntu

20.04
18.04

Debian

bullseye

Installation

Une des options :

ansible-galaxy install grzegorznowak.cardano_node
Cloner le dépôt directement

Exemple de playbook

Il existe 2 modes principaux d'installation :

Compilation à partir de la source
Utilisation de binaires d'installation pré-construits de IOHK

Contrôlable avec le drapeau cardano_install_method. Voir la section Configuration ci-dessous.

L'installation de binaires devrait convenir à la plupart des cas, mais n'hésitez pas à utiliser la source pour débloquer la construction ultime.

Ce rôle tente de tester les deux approches.

Lorsqu'il est cloné depuis GitHub

- name: Converger le Noeud Cardano
  hosts: all
  vars:
    cncli_add: true  # inclura CNCLI
    cardano_wallets:  # créera deux portefeuilles pour vous
      - savings
      - operations
  roles:
    - cardano-node-role

Lorsqu'il est installé avec ansible-galaxy

- name: Converger le Noeud Cardano
  hosts: all
  vars:
    cncli_add: true  # inclura CNCLI
    cardano_wallets:  # créera deux portefeuilles pour vous
      - savings
      - operations
  roles:
    - grzegorznowak.cardano_node

Configuration & Utilisation

Par défaut, installe Cardano pour un utilisateur et un groupe cardano. C'est une pratique recommandée. Tous les autres réglages à ajuster se trouvent sous defaults/main.yml.

Des exemples d'utilisation plus détaillés et des commandes prêtes à copier-coller seront disponibles lors des prochaines mises à jour.

Tokens NFT

Crée des tokens NFT natifs de manière idempotente avec ce rôle. Je ne tenterai pas de nouveau de créer le token s'il est déjà présent et en quantité désirée.

À ce stade, les tokens créés sont envoyés à l'adresse utilisée pour la création.

Configuration minimale requise sur mainnet :

cardano_install_method: dist
active_network: main
cardano_wallets:
  - &wallet_default default
cardano_nfts:
  - slug: BurningGiraffe
    description: Girafe Brûlante
    image: ""  # un hash IPFS du NFT
    name: Girafe Brûlante
    id: 1
    open_period: 1000000  
    quantity: 10
    wallet: *wallet_default

Tokens Natifs

Crée des tokens natifs (pas des NFT) de manière idempotente avec ce rôle. Je ne tenterai pas de nouveau de créer le token s'il est déjà présent et en quantité désirée.

À ce stade, les tokens créés sont envoyés à l'adresse utilisée pour la création.

Configuration minimale requise sur mainnet :

cardano_install_method: dist
active_network: main
cardano_wallets:
  - &wallet_default default
cardano_assets:
  - name: MonActif
    quantity: 1000000
    wallet: *wallet_default

Adresses de Paiement

Nous pouvons suivre les adresses ADA dont nous disposons.

NOTE : Ce rôle n'intègre pas (encore) de logiciel de portefeuille. Ce que nous faisons, c'est créer les fichiers nécessaires pour envoyer et recevoir des paiements en utilisant des commandes cli. "Portefeuille" dans ce contexte signifie un chemin nommé qui contient des fichiers appartenant ensemble.

L'approche actuelle est de ne créer que les portefeuilles qui n'existent pas, et de signaler s'ils en trouvent qui sont corrompus - c'est-à-dire manquant des clés privées. Pour des raisons de sécurité, nous ne tenterons pas de supprimer les portefeuilles existants, même si cela va à l'encontre de la philosophie ansible de définir et de converger vers un état spécifié du système.

# Ajouter une liste de noms de portefeuilles que vous souhaitez suivre avec le rôle
cardano_wallets:
  - savings
  - operations

Basé sur l'exemple ci-dessus - en supposant que toutes les valeurs par défaut sont utilisées - les adresses des portefeuilles seront situées sous :

/home/cardano/wallets/savings/payment.addr
/home/cardano/wallets/operations/payment.addr

avec les clés privées des portefeuilles.

Assertion de Statut de Synchronisation du Noeud

Bloque l'exécution d'un playbook jusqu'à ce que le noeud Cardano soit entièrement synchronisé.

- name: Attendre jusqu'à ce que nous soyons entièrement synchronisés
  assert_cardano_synced:
    cardano_node_socket: "{{ cardano_node_socket }}"
    cardano_bin_path: "{{ cardano_bin_path }}"
    active_network: "{{ active_network }}"
    testnet_magic: "{{ network_magic }}"  # utilisé uniquement sur testnet
  retries: 60
  delay: 240    # attendre jusqu'à 4h pour synchronisation complète
  become: true
  become_user: "{{ cardano_user }}"
  register: sync_check_result
  until: sync_check_result.progress | int == 100

Assertion de Fonds

Assurez-vous qu'une adresse spécifique dispose d'au moins le montant d'Ada donné. Utile pour surveiller un service qui doit avoir toujours un certain montant d'Ada, ou bloquer des opérations spécifiques qui nécessitent certaines montants disponibles.

- set_fact
      wallet_to_check: default
      lovelace_needed: 1000000000

- name: Collecter les portefeuilles
  cardano_wallet:
    cardano_bin_path: "{{ cardano_bin_path }}"
    name: "{{ wallet_to_check }}"
    active_network: "{{ active_network }}"
    testnet_magic: "{{ network_magic }}"  # utilisé uniquement sur testnet
  become: true
  become_user: "{{ cardano_user }}"
  register: wallet_results

- name: S'assurer que nous avons des Lovelace
  assert_address_funded:
    cardano_node_socket: "{{ cardano_node_socket }}"
    cardano_bin_path: "{{ cardano_bin_path }}"
    active_network: "{{ active_network }}"
    testnet_magic: "{{ network_magic }}"  # utilisé uniquement sur testnet
    expected_lovelace: "{{ lovelace_needed }}"
    address: "{{ wallet_results['wallets_addresses'][wallet_to_check] }}"    
  retries: 60
  delay: 240    # attendre jusqu'à 4h pour synchronisation complète
  become: true
  become_user: "{{ cardano_user }}"
  register: lovelace_result
  until: lovelace_result.lovelace | int > lovelace_needed

Paramètres Généraux

# Utilisateur Cardano
cardano_user: cardano
cardano_group: cardano
cardano_home_directory: "/home/{{ cardano_user }}"

# options possibles :
# src - compiler à partir de la source
# dist - utiliser le binaire officiel
cardano_install_method: dist

# Variables de version
ghc_version: 8.10.4
cabal_version: 3.4.0.0

# Applicable uniquement lors de la construction à partir de src
cardano_node_version: 1.33.0

# Applicable uniquement lors de l'installation à partir de dist
cardano_hydra_build: 9941151
# confirmez toujours votre sha, ou un poison pourrait arriver
cardano_dist_sha_256: eb7fbc652f79bcb8f56699ed7fee174a4ed321307c7086838d44972136795543
cardano_dist_url: "https://hydra.iohk.io/build/{{ cardano_hydra_build }}/download/1"

# Configuration du service
cardano_listen_addr: 127.0.0.1
cardano_listen_port: 22322  # doit être dans la plage haute s'il fonctionne en tant qu'utilisateur non privilégié

# Configuration CNCLI
cncli_add: false  # à mettre sur 'true' pour activer cncli avec le service cncli-sync

Il y a plus, donc allez directement au fichier defaults/main.yml pour voir tous les petits détails.

Cardano CLI

Un des objectifs finaux de ce dépôt est d'abstraire les opérations Cardano avec des tâches ansible, mais rien ne vous empêche d'interagir directement avec les services et binaires.

su cardano
cd ~/bin
./cardano-cli --help

Pour des détails sur l'utilisation, allez à la documentation de cardano-cli directement.

CNCLI

Pour des détails sur l'utilisation, consultez le dépôt original.

Gestion des Services

Utilisez-le comme tout autre service

# gestion du processus cardano-node :
systemctl status cardano-node
systemctl restart cardano-node

# voir les journaux généraux
journalctl -u cardano-node

Interagir avec le service de synchronisation CNCLI, lorsqu'il est activé.

# gestion du processus cncli-sync
systemctl status cncli-sync
systemctl restart cncli-sync

# voir les journaux généraux
journalctl -u cncli-sync

Tests d'Intégration

localement sur LXD

LXD doit déjà être installé et configuré.

Déclenchez la suite complète avec ./test-local.sh.

La compilation des binaires requis est une tâche gourmande en CPU, soyez donc préparé pour un processus long.

sur le Cloud via le pipeline CI

CI construit sur l'infrastructure DO et est déclenché à chaque modification significative dans la branche main.

Pour limiter les coûts d'exécution, la CI à partir de la source est actuellement faite uniquement contre Focal Fossa.

La CI binaire pré-construite est faite contre focal et bionic.

Les autres plateformes supportées sont évaluées localement.

Motivation

Ce rôle est une exploration continue de la configuration des services et de l'arrière-plan de Cardano, avec des fonctionnalités qui grandiront au fil du temps à mesure que nous comprenons mieux l'espace de recherche.

Réalisé selon des normes élevées de TDD et de codage, en veillant à ce que les modifications ne cassent aucun des composants existants.

N'oubliez jamais de demander des tests lorsque vous commandez votre pizza ansible.

Quand devrais-je utiliser ce rôle plutôt que l'image docker officielle ?

Tout d'abord, Docker est un excellent outil que j'utilise beaucoup dans mes projets pour fournir des images cohérentes pour des tâches concrètes. La spécificité de Docker a un prix et cela ne devient pas amusant quand il s'agit de réseau ou de systemd. Par lui-même, il ne peut réellement pas faire toutes ces choses complètement et voilà Kubernetes, Docker Swarms, etc. Ce qui est très bien jusqu'à ce que vous ayez vraiment besoin d'une configuration sur mesure avec VPN mesh ou surveillance de services en direct - vous commencez à ajouter couche après couche de complexité au système uniquement pour résoudre des problèmes que Docker lui-même a causés ; avec de nombreuses dépendances qui ne sont pas faciles à déployer avec le principe d'infrastructure en tant que code.

Si j'ai appris quelque chose au fil des ans en développement, c'est qu'il n'y a véritablement aucune solution qui convienne à tout. À un moment donné, lorsqu'une plateforme de qualité production est envisagée, essayer d'adapter Docker aux cadres d'un environnement bien défini et contrôlé nécessite beaucoup plus de travail que de compiler un ensemble bien compris et minimal de rôles qui apportent une valeur spécifique.

Si vous ne développez pas le système avec une approche de type Docker en premier, ce que je trouve personnellement vraiment une méthode détournée, vous pourriez apprécier ce rôle. Avec la valeur ajoutée d’être parfaitement transparent ; donc vous ne vous inquiétez jamais de ce que votre image Docker contient prépackagée autre que ce qu'elle prétend.

Les tests initiaux ont été réalisés en utilisant des conteneurs LXD, qui sont légers, rapides et natifs d'Ubuntu, et peuvent simuler de vrais serveurs à un niveau que Docker ne peut vraiment pas.

À Noter

Grâce à Molecule, nous sommes actuellement à l'ère de l'infrastructure en tant que code orientée tests. Ce projet en est aussi une manifestation. Alors veuillez consulter https://github.com/ansible-community/molecule et lui donner un peu d'amour et d'attention.