Vos playbooks Ansible, exécutés par un moteur rapide écrit en Rust.

Volant lit les playbooks, rôles et inventaires que vous avez déjà et les exécute par SSH. Rien à convertir.

curl -fsSL https://volant.sh/install.sh | sh

Linux et macOS, x86_64 et arm64. Ansible n'est pas nécessaire. Windows n'est pas encore pris en charge.

pré-alpha Il exécute de vrais playbooks, pas encore tous. Essayez-le sur un hôte que vous pouvez vous permettre de modifier, et voyez ce qu'il laisse sur vos machines.

Une exécution, cinq hôtes.

Une vraie exécution de Volant, rejouée. Chaque rayon de la roue représente un hôte et prend la couleur du résultat qu'il renvoie, avec les couleurs d'ansible-playbook.

  • web1en attente
  • web2en attente
  • web3en attente
  • db1en attente
  • db2en attente

volant playbook -i inventory.ini site.yml

PLAY [all] *********************************************************************

TASK [Check the host answers] **************************************************
ok: [web1]
ok: [web2]
ok: [web3]
ok: [db1]
ok: [db2]

TASK [Write the app config] ****************************************************
changed: [web1]
changed: [web2]
changed: [web3]
changed: [db1]
changed: [db2]

TASK [Reload the web server] ***************************************************
changed: [web1]
changed: [web2]
changed: [web3]
skipping: [db1]
skipping: [db2]

TASK [Check the database port] *************************************************
skipping: [web1]
skipping: [web2]
skipping: [web3]
ok: [db1]
ok: [db2]

PLAY RECAP *********************************************************************
db1                        : ok=3    changed=1    unreachable=0    failed=0    skipped=1    rescued=0    ignored=0
db2                        : ok=3    changed=1    unreachable=0    failed=0    skipped=1    rescued=0    ignored=0
web1                       : ok=3    changed=2    unreachable=0    failed=0    skipped=1    rescued=0    ignored=0
web2                       : ok=3    changed=2    unreachable=0    failed=0    skipped=1    rescued=0    ignored=0
web3                       : ok=3    changed=2    unreachable=0    failed=0    skipped=1    rescued=0    ignored=0
Le playbook et l'inventaire de cette exécution
- hosts: all
  gather_facts: false
  tasks:
    - name: Check the host answers
      ping:

    - name: Write the app config
      copy:
        dest: "/tmp/volant-demo/out/{{ inventory_hostname }}.conf"
        content: "role={{ group_names | first }}\n"

    - name: Reload the web server
      command: "true"
      when: "\"web\" in group_names"

    - name: Check the database port
      command: "true"
      changed_when: false
      when: "\"db\" in group_names"
[web]
web1
web2
web3

[db]
db1
db2

[all:vars]
ansible_connection=local
ansible_python_interpreter=/usr/bin/python3

Enregistré avec Volant 0.1.0-alpha.10 sur cinq hôtes via une connexion locale, et rejoué ici à vitesse de lecture. La sortie est celle qui a été affichée.

Comment ça marche.

ansible-playbook paie le démarrage d'un nouvel interpréteur Python sur l'hôte à chaque tâche. Volant ne le paie qu'une fois par exécution, puis garde une connexion ouverte pour le reste.

ansible-playbook à chaque tâche, sur chaque hôte

  1. construire la charge utile du module
  2. l'envoyer par SSH
  3. démarrer Python
  4. importer module_utils
  5. exécuter le module

Volant une fois par exécution

  1. téléverser un petit agent, mis en cache sur l'hôte
  2. ouvrir une connexion SSH par hôte

ensuite pour chaque tâche

  1. envoyer la tâche sur la connexion ouverte
  2. y répondre en Rust, ou forker un Python préchauffé

Les modules courants comme apt, systemd, file, lineinfile et la collecte des facts sont traités en Rust par l'agent quand les arguments de la tâche le permettent. Tout autre module s'exécute en Python, dans un serveur qui a chargé ses imports une seule fois. Comment le moteur est construit

Mêmes fichiers, même commande.

volant playbook accepte les options d'ansible-playbook et affiche la sortie que vous connaissez, jusqu'au récapitulatif. Tout ce que votre projet contient déjà est lu tel quel.

Exécuter votre premier playbook

ansible.cfg
lu aux mêmes endroits, avec la même priorité
Inventaires
INI, YAML, TOML, scripts et plugins d'inventaire
group_vars et host_vars
superposés dans l'ordre d'Ansible
Vault
fichiers et valeurs chiffrés, --ask-vault-pass et --vault-id
Rôles et collections
dépendances, spécifications d'arguments et collections installées
Ligne de commande
les options d'ansible-playbook, dont --check et --diff

Il dit non avant de toucher un hôte.

Volant vérifie tout le playbook avant de se connecter. La plupart de ce que cette version ne sait pas exécuter y est nommé, avec le play ou la tâche concernés, et l'exécution s'arrête avec le code 4. Rien n'a changé sur aucun hôte.

--syntax-check et les listes ne s'arrêtent jamais sur ce qui n'est pas pris en charge, et --check avec --diff montre ce qu'une vraie exécution changerait. Vérifier un projet

$ volant playbook -i inventory.ini site.yml 
ERROR! play 1: strategy 'mitogen_free' is not supported yet
Sortie réelle de Volant 0.1.0-alpha.10, pour un play qui demande une stratégie absente de cette version.
Ce qu'il télécharge
son propre Python et ansible-core, environ 155 MB, la première fois qu'un playbook a besoin de Python
Comment il le vérifie
chaque fichier contre un hash fixé dans la version
Où il le range
~/.local/share/volant/runtime, à l'écart de tout Python du système
Collections
volant runtime install --collections community.general
Sans réseau
volant runtime pack sur une machine, install --from sur l'autre

Pas d'Ansible à installer.

Le binaire embarque les agents qu'il téléverse sur vos hôtes. Quand un playbook a besoin d'un module Python, Volant installe son propre runtime et le garde à l'écart du reste de la machine.

Le runtime géré

Ce que Volant promet.

Vos fichiers restent les vôtres

Pas d'étape de conversion ni de nouveau format. Les mêmes fichiers continuent de fonctionner avec ansible-playbook.

Les refus d'abord

La plupart de ce que cette version ne sait pas exécuter est nommé avant la première connexion, et rien ne s'exécute.

Linux par SSH d'abord

Hôtes Linux par SSH et connexions locales aujourd'hui. Windows et les équipements réseau viendront plus tard.

Aucune télémétrie

Volant n'effectue aucun appel réseau autre que ceux que demande votre playbook, et le téléchargement du runtime.

Développé en public.

Volant est sous GPL-3.0-or-later, comme Ansible. La feuille de route, les tickets et les décisions de conception sont publics.