Con el fin de acercar un poco más el uso de Ansible al usuario final exploramos aquí tres opciones para ejecutar playbooks desde una interfaz gráfica.

Las opciones tomadas en cuenta son:

AWX

AWX es la versión libre del proyecto Ansible Tower el cual es una interfaz gráfica (de pago) para ejecutar Ansible.

AWX el software (no pago) más popular para ejecutar Ansible desde una interfaz gráfica (abreviado gui), contando con 427 colaboradores en su repositorio de Github.

AWX está construido con las tecnologías Python y Nodejs.

Instalación

En nuestro caso probamos la instalación con docker-compose , este tipo de instalación no es la recomendada, la manera recomendada de instalar AWX es usando el operador AWX desde Kubernetes.

Para instalar AWX debemos ejecutar en una terminal linux los siguientes comandos:

apt update
apt install -y ansible apt-transport-https ca-certificates curl docker
apt install -y docker-compose gnupg2 software-properties-common unzip
git clone https://github.com/ansible/awx
cd /home/user/awx
echo "pg_password='mi_password_pg'" >> /tools/docker-compose/inventory
echo "broadcast_websocket_secret='mi_broadcast_websocket_secret'" >> /tools/docker-compose/inventory
echo "secret_key='mi_secret_key'" >> ./tools/docker-compose/inventory
PYTHON=python3 COMPOSE_TAG=latest make docker-compose-build
PYTHON=python3 COMPOSE_TAG=latest make docker-compose COMPOSE_UP_OPTS=-d
docker exec tools_awx_1 make clean-ui ui-devel

Estos pasos crean un contenedor Centos 9 que ejecuta AWX.

Adicionalmente hay que configurar el servidor NginX como un proxy reverso para poder mostrar la interfaz gráfica web.

Ya deberíamos poder ver la interfaz web de AWX en la dirección https://ip_de_nuestro_servidor.

Si desea ver el proceso de instalación en detalle puede revisar este enlace.

Uso

Una vez instalado AWX , visitamos la página de ingreso:

Antes de poder ejecutar playbooks con AWX debemos configurar primero algunas variables, empezamos por agregar una organización predeterminada:

Luego agregamos la llave SSH privada del servidor AWX como una credencial:

Después debe agregarse un inventario:

Ahora creamos un proyecto que es el repositorio desde el cual vamos a clonar la colección Ansible que vamos a usar:

Seguidamente agregamos un servidor y a la vez lo incluimos dentro del inventario que habíamos creado anteriormente:

Luego creamos una plantilla que es el equivalente a usar un playbook, en este caso usamos el playbook ping.yml:

Una vez agregada toda esa configuración ya podemos ejecutar la plantilla (playbook) usando el botón con forma de cohete que se muestra en la lista de plantillas:

Esto mostrará la ejecución en tiempo real:

Ventajas

• Es la herramienta gráfica más popular para ejecutar Ansible.
• Posee gran cantidad de opciones para diferentes necesidades.
• Puede usarse con Kubernetes

Desventajas

• Difícil de instalar y configurar.
• Requiere más recursos para ejecutarse.
• Las ejecuciones a veces dan error o se quedan pegadas.
• Las variables quedan almacenadas en una base de datos PostgreSQL, esto causa que dichas variables solo puedan ser usadas desde la interfaz web de AWX pero no desde terminal con ansible-playbook (pero sí pueden ser exportadas).

Ansible Semaphore

Ansible semaphore es una interfaz gráfica web escrita en GO para ejecutar playbooks.

En su repositorio de Github este proyecto cuenta con 75 colaboradores.

Instalación

Ansible semaphore puede instalarse usando snap o usando docker-compose.

Snap

Instale snapd:

sudo apt install -y snapd

Instale el núcleo de snap (frecuentemente hay que ejecutar este comando dos veces):

snap install core

Use snap para instalar Ansible semaphore:

sudo snap install semaphore

Agregue el usuario administrador para semaphore:

sudo /snap/bin/semaphore user add --admin --name "admin" --login admin --email admin@guerrillamail.com --password codigosur

Visite en un navegador web la dirección http://localhost:3000.

docker

Si queremos servir Ansible Semaphore a través de internet y no solo localmente debemos usar la instalación vía Docker Compose, para ello creamos el archivo docker-compose.yml con el siguiente contenido:

version: '3'

services:
  mysql:
    restart: unless-stopped
    image: mysql:8.0
    hostname: mysql
    environment:
      MYSQL_RANDOM_ROOT_PASSWORD: 'no'
      MYSQL_DATABASE: semaphore
      MYSQL_USER: admin
      MYSQL_PASSWORD: codigosur

  semaphore:
    restart: unless-stopped
    ports:
      - 3000:3000
    image: semaphoreui/semaphore:latest
    container_name: semaphore
    environment:
      SEMAPHORE_DB_USER: admin
      SEMAPHORE_DB_PASS: codigosur
      SEMAPHORE_DB_HOST: mysql
      SEMAPHORE_DB_PORT: 3306
      SEMAPHORE_DB: semaphore
      SEMAPHORE_PLAYBOOK_PATH: /tmp/semaphore/
      SEMAPHORE_ADMIN_PASSWORD: codigosur
      SEMAPHORE_ADMIN_NAME: admin
      SEMAPHORE_ADMIN_EMAIL: admin@guerrillamail.com
      SEMAPHORE_ADMIN: admin
      SEMAPHORE_ACCESS_KEY_ENCRYPTION: Llave_de_encripcion_aqui
    depends_on:
      - mysql

Y luego ejecutamos el comando:

docker-compose up

Finalmente y de igual forma que se hizo con AWX, debemos configurar NginX como un proxy reverso para poder mostrar la interfaz de Semaphore en un navegador web.

Uso

Al igual que con AWX, para Semaphore hay que configurar algunas variables antes de poder ejecutar un playbook.

Visitamos la dirección http://localhost:3000 y nos autenticamos:

Luego debemos crear un proyecto:

Seguidamente debemos agregar nuestra llave SSH privada a la aplicación:

Y también agregamos agregamos una llave de tipo None (nada) frecuentemente utilizada:

Después, agregamos el repositorio en el cual se encuentra la colección que deseamos instalar:

Luego demos crear un ambiente (vacío) que es obligatorio:

Después agregamos un inventario:

Ahora agregamos una plantilla que al igual que con AWX es equivalente a un playbook:

Ya podemos ejecutar nuestra plantilla usando el botón run desde la lista de plantillas:

A continuación se muestra un ejemplo de la salida mostrada durante una ejecución:

Ventajas

• Fácil de instalar en la versión local.
• Simple.
• Interfaz agradable.

Desventajas

• Cuenta con menos opciones que AWX.
• Antes de correr cada playbook siempre clona el repositorio e instala los requerimientos lo que agrega una cantidad considerable de tiempo a las ejecuciones.
• Las variables quedan almacenadas en una base de datos (que puede ser MySQL, PostgreSQL o BoltDB) y al igual que con AWX esto provoca que puedan usarse desde el GUI de Semaphore pero no desde terminal (con ansible-playbook).
• A diferencia de AWX, con Ansible Semaphore no se pueden exportar las variables.
• En la versión Docker la aplicación ejecuta los playbooks siempre con el usuario semaphore (este es el usuario que el contenedor Docker tiene creado en el OS), dado esto siempre hay que enviar la variable ansible_user=root.

Guibox

Guibox es una aplicación personalizada escrita usando el microframework Python Flask y el framework javascript Nodejs.

La diferencia entre esta opción versus las opciones AWX y Semaphore es que Guibox lee las variables desde un repositorio git y no las guarda en una base de datos, permitiendo su desacople al estar las variables almacenadas off-site.

Tomemos como ejemplo la colección infrainabox que tiene la siguiente estructura de directorios:

infrainabox/
├── playbooks
│   └── docker.yml
├── requirements.yml
└── roles
    └── docker
        ├── defaults
        │   └── main.yml
        └── tasks
            └── main.yml

Ahora, creamos un repositorio (aparte) que contiene las variables que enviaremos hacia los playbooks de la colección infrainabox, de tal manera que nuestro nuevo repositorio (llamado aquí ansible_runner) tiene la estructura mostrada:

ansible_runner/
├── inventory
│   └── group_vars
│       └── docker.yml
└── requirements.yml

Y en el archivo de variables de grupo docker.yml tenemos las siguientes variables:

---
docker_container_name: 'infrainabox_container'
docker_container_image: 'geerlingguy/docker-debian11-ansible'
docker_container_op: 'create'

Guibox toma estas variables de grupo y las convierte en un formulario web que al ser enviado desencadena la ejecución de un playbook.

Instalación

Para instalarlo clonamos el repositorio guibox:

git clone https://oauth2:glpat-bkyHM5SDjYYFzRWoBJtS@git.codigosur.org/ansible/guibox.git

Ingresamos en la carpeta recién clonada:

cd guibox

Ejecutamos guibox con docker-compose:

docker-compose up flask-dev

Visitamos la dirección http://localhost:8080 en un navegador web.

Uso

Al visitar la dirección http://localhost:8080 deberemos ingresar con usuario y contraseña:

Una vez que ingresamos damos click en el botón Configuración:

Esto nos lleva al formulario de configuración, ahí damos click en el botón Submit para instalar los requerimientos:

Una vez instalados los requerimientos volvemos a la página home y damos click en el botón Playbooks, esto nos muestra la lista de playbooks que hay disponibles:

En esta lista damos click en el playbook que deseamos ejecutar (docker en este ejemplo), esto nos muestra el formulario con las variables que habíamos escrito anteriormente (en el archivo docker.yml):

Una vez que editamos las variables del formulario web a nuestro gusto, damos click en el botón Submit para ejecutar el playbook:

Ventajas

• Fácil de instalar.
• Simple
• Puede empaquetarse dentro de la colección infrainabox como el gui para ejecutar esta colección sin tener que instalar nada más que Docker.

Desventajas

• No almacena variables.
• No almacena inventarios
• Muy limitado en opciones.
• Existe un costo de mantenimiento de la aplicación.