Tus playbooks de Ansible, ejecutados por un motor rápido escrito en Rust.

Volant lee los playbooks, roles e inventarios que ya tienes y los ejecuta por SSH. Nada que convertir.

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

Linux y macOS, x86_64 y arm64. No hace falta Ansible. Windows todavía no está soportado.

pre-alpha Ejecuta playbooks reales, pero todavía no todos. Pruébalo en un host que puedas permitirte tocar y mira lo que deja en tus máquinas.

Una ejecución, cinco hosts.

Una ejecución real de Volant, reproducida de nuevo. Cada radio de la rueda representa un host y toma el color del resultado que devuelve, con los colores que usa ansible-playbook.

  • web1esperando
  • web2esperando
  • web3esperando
  • db1esperando
  • db2esperando

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
El playbook y el inventario de esta ejecución
- 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

Grabado con Volant 0.1.0-alpha.10 en cinco hosts mediante una conexión local y reproducido aquí a velocidad de lectura. La salida es lo que se imprimió.

Cómo funciona.

ansible-playbook paga un intérprete de Python nuevo en el host por cada tarea. Volant paga una vez por ejecución y mantiene una conexión abierta para el resto.

ansible-playbook por cada tarea, en cada host

  1. construir el payload del módulo
  2. enviarlo por SSH
  3. iniciar Python
  4. importar module_utils
  5. ejecutar el módulo

Volant una vez por ejecución

  1. subir un agente pequeño, en caché en el host
  2. abrir una conexión SSH por host

después por cada tarea

  1. enviar la tarea por la conexión abierta
  2. responderla en Rust, o hacer fork de un Python ya caliente

Los módulos comunes como apt, systemd, file, lineinfile y la recopilación de facts los responde el agente en Rust cuando los argumentos de la tarea lo permiten. Cualquier otro módulo se ejecuta en Python, en un servidor que cargó sus imports una sola vez. Cómo está construido el motor

Los mismos archivos, el mismo comando.

volant playbook acepta las opciones de ansible-playbook e imprime la salida que conoces, hasta el recap. Todo lo que tu proyecto ya tiene se lee tal cual.

Ejecuta tu primer playbook

ansible.cfg
se lee de los mismos sitios, con la misma precedencia
Inventarios
INI, YAML, TOML, scripts y plugins de inventario
group_vars y host_vars
en capas según el orden de Ansible
Vault
archivos y valores cifrados, --ask-vault-pass y --vault-id
Roles y colecciones
dependencias, especificaciones de argumentos y colecciones instaladas
Línea de comandos
las opciones de ansible-playbook, incluidas --check y --diff

Dice que no antes de tocar un host.

Volant comprueba todo el playbook antes de conectarse. La mayor parte de lo que esta versión no puede ejecutar se nombra ahí, con el play o la tarea en que está, y la ejecución se detiene con el código 4. Nada ha cambiado en ningún host.

--syntax-check y los listados nunca se detienen por algo no soportado, y --check con --diff muestra lo que cambiaría una ejecución real. Comprobar un proyecto

$ volant playbook -i inventory.ini site.yml 
ERROR! play 1: strategy 'mitogen_free' is not supported yet
Salida real de Volant 0.1.0-alpha.10, para un play que pide una estrategia que esta versión no tiene.
Qué descarga
su propio Python y ansible-core, unos 155 MB, la primera vez que un playbook necesita Python
Cómo lo comprueba
cada archivo contra un hash fijado en la versión
Dónde lo guarda
~/.local/share/volant/runtime, aparte de cualquier Python del sistema
Colecciones
volant runtime install --collections community.general
Sin red
volant runtime pack en una máquina, install --from en la otra

Sin Ansible que instalar.

El binario lleva los agentes que sube a tus hosts. Cuando un playbook necesita un módulo de Python, Volant instala un runtime propio y lo mantiene aparte del resto de la máquina.

El runtime administrado

Lo que Volant promete.

Tus archivos siguen siendo tuyos

Sin paso de conversión ni formato nuevo. Los mismos archivos siguen funcionando con ansible-playbook.

Primero los rechazos

La mayor parte de lo que esta versión no puede ejecutar se nombra antes de la primera conexión, y no se ejecuta nada.

Primero Linux por SSH

Hoy, hosts Linux por SSH y conexiones locales. Windows y los dispositivos de red llegarán después.

Sin telemetría

Volant no hace ninguna llamada de red aparte de las que pide tu playbook y la descarga del runtime.

Construido en abierto.

Volant es GPL-3.0-or-later, como Ansible. La hoja de ruta, los issues y las decisiones detrás del diseño son públicos.